com.iabtcf.decoder.TCString

Here are the examples of the java api com.iabtcf.decoder.TCString taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

67 Examples 7

19 Source : PurposeStrategy.java
with Apache License 2.0
from prebid

protected Collection<VendorPermission> allowedByFullTypeStrategy(TCString vendorConsent, boolean isEnforceVendors, Collection<VendorPermissionWithGvl> vendorForPurpose, Collection<VendorPermissionWithGvl> excludedVendors) {
    return fullEnforcePurposeStrategy.allowedByTypeStrategy(getPurpose(), vendorConsent, vendorForPurpose, excludedVendors, isEnforceVendors);
}

19 Source : PurposeStrategy.java
with Apache License 2.0
from prebid

protected Collection<VendorPermission> allowedByNoTypeStrategy(TCString vendorConsent, boolean isEnforceVendors, Collection<VendorPermissionWithGvl> vendorForPurpose, Collection<VendorPermissionWithGvl> excludedVendors) {
    return noEnforcePurposeStrategy.allowedByTypeStrategy(getPurpose(), vendorConsent, vendorForPurpose, excludedVendors, isEnforceVendors);
}

19 Source : PurposeStrategy.java
with Apache License 2.0
from prebid

protected Collection<VendorPermission> allowedByBasicTypeStrategy(TCString vendorConsent, boolean isEnforceVendors, Collection<VendorPermissionWithGvl> vendorForPurpose, Collection<VendorPermissionWithGvl> excludedVendors) {
    return basicEnforcePurposeStrategy.allowedByTypeStrategy(getPurpose(), vendorConsent, vendorForPurpose, excludedVendors, isEnforceVendors);
}

19 Source : TcfDefinerService.java
with Apache License 2.0
from prebid

private TcfContext defaultTcfContext(String consentString, TCString consent, String ipAddress) {
    return TcfContext.builder().gdpr(gdprDefaultValue).consentString(consentString).consent(consent).ipAddress(ipAddress).build();
}

19 Source : TcfDefinerService.java
with Apache License 2.0
from prebid

private static boolean isConsentValid(TCString consent) {
    return consent != null && !(consent instanceof TCStringEmpty);
}

19 Source : TcfDefinerService.java
with Apache License 2.0
from prebid

private TcfContext updateGeoFailedMetricAndReturnDefaultTcfContext(Throwable exception, String consentString, TCString consent, String ipAddress) {
    final String message = String.format("Geolocation lookup failed: %s", exception.getMessage());
    logger.warn(message);
    logger.debug(message, exception);
    metrics.updateGeoLocationMetric(false);
    return defaultTcfContext(consentString, consent, ipAddress);
}

19 Source : TcfDefinerService.java
with Apache License 2.0
from prebid

private String maybeMaskIp(String ipAddress, TCString consent) {
    return shouldMaskIp(consent) ? ipAddressHelper.maskIpv4(ipAddress) : ipAddress;
}

19 Source : TcfDefinerService.java
with Apache License 2.0
from prebid

private static boolean shouldMaskIp(TCString consent) {
    return isConsentValid(consent) && consent.getVersion() == 2 && !consent.getSpecialFeatureOptIns().contains(1);
}

19 Source : Tcf2Service.java
with Apache License 2.0
from prebid

public Future<Collection<VendorPermission>> permissionsFor(Set<Integer> vendorIds, TCString tcfConsent) {
    return permissionsForInternal(vendorPermissions(vendorIds), tcfConsent, null);
}

18 Source : FullEnforcePurposeStrategy.java
with Apache License 2.0
from prebid

private boolean isAllowedByRestrictionTypePurpose(Purpose purpose, Integer vendorId, boolean isEnforceVendor, TCString tcString, RestrictionType restrictionType) {
    switch(restrictionType) {
        case REQUIRE_CONSENT:
            return isAllowedBySimpleConsent(purpose, vendorId, isEnforceVendor, tcString);
        case REQUIRE_LEGITIMATE_INTEREST:
            return isAllowedByLegitimateInterest(purpose, vendorId, isEnforceVendor, tcString);
        case UNDEFINED:
            return isAllowedBySimpleConsentOrLegitimateInterest(purpose, vendorId, isEnforceVendor, tcString);
        default:
            return false;
    }
}

18 Source : EnforcePurposeStrategy.java
with Apache License 2.0
from prebid

protected boolean isAllowedBySimpleConsentOrLegitimateInterest(Purpose purpose, Integer vendorId, boolean isEnforceVendor, TCString tcString) {
    return isAllowedBySimpleConsent(purpose, vendorId, isEnforceVendor, tcString) || isAllowedByLegitimateInterest(purpose, vendorId, isEnforceVendor, tcString);
}

18 Source : PurposeStrategy.java
with Apache License 2.0
from prebid

private Collection<VendorPermission> allowedByTypeStrategy(TCString vendorConsent, Purpose purpose, Collection<VendorPermissionWithGvl> vendorForPurpose, Collection<VendorPermissionWithGvl> excludedVendors) {
    final boolean isEnforceVendors = BooleanUtils.isNotFalse(purpose.getEnforceVendors());
    final EnforcePurpose purposeType = purpose.getEnforcePurpose();
    if (Objects.equals(purposeType, EnforcePurpose.basic)) {
        return allowedByBasicTypeStrategy(vendorConsent, isEnforceVendors, vendorForPurpose, excludedVendors);
    }
    if (Objects.equals(purposeType, EnforcePurpose.no)) {
        return allowedByNoTypeStrategy(vendorConsent, isEnforceVendors, vendorForPurpose, excludedVendors);
    }
    // Full by default
    if (purposeType == null || Objects.equals(purposeType, EnforcePurpose.full)) {
        return allowedByFullTypeStrategy(vendorConsent, isEnforceVendors, vendorForPurpose, excludedVendors);
    }
    throw new IllegalArgumentException(String.format("Invalid type strategy provided. no/base/full != %s", purposeType));
}

18 Source : PurposeStrategy.java
with Apache License 2.0
from prebid

public Collection<VendorPermission> processTypePurposeStrategy(TCString vendorConsent, Purpose purpose, Collection<VendorPermissionWithGvl> vendorPermissions, boolean wasDowngraded) {
    final Collection<VendorPermissionWithGvl> excludedVendors = excludedVendors(vendorPermissions, purpose);
    final Collection<VendorPermissionWithGvl> vendorForPurpose = vendorPermissions.stream().filter(vendorPermission -> !excludedVendors.contains(vendorPermission)).collect(Collectors.toList());
    allowedByTypeStrategy(vendorConsent, purpose, vendorForPurpose, excludedVendors).stream().map(VendorPermission::getPrivacyEnforcementAction).forEach(this::allow);
    final Collection<VendorPermission> naturalVendorPermission = wasDowngraded ? allowedByBasicTypeStrategy(vendorConsent, true, vendorForPurpose, excludedVendors) : allowedByFullTypeStrategy(vendorConsent, true, vendorForPurpose, excludedVendors);
    naturalVendorPermission.stream().map(VendorPermission::getPrivacyEnforcementAction).forEach(this::allowNaturally);
    return vendorPermissions.stream().map(VendorPermissionWithGvl::getVendorPermission).collect(Collectors.toList());
}

18 Source : TcfDefinerService.java
with Apache License 2.0
from prebid

private TcfContext tcfContextFromGeo(GeoInfo geoInfo, String consentString, TCString consent, String ipAddress) {
    metrics.updateGeoLocationMetric(true);
    final Boolean inEea = isCountryInEea(geoInfo.getCountry());
    return TcfContext.builder().gdpr(gdprFromGeo(inEea)).consentString(consentString).consent(consent).geoInfo(geoInfo).inEea(inEea).ipAddress(ipAddress).build();
}

18 Source : TcfDefinerService.java
with Apache License 2.0
from prebid

private Future<TcfContext> toTcfContext(Privacy privacy, String country, String ipAddress, RequestLogInfo requestLogInfo, Timeout timeout) {
    final String consentString = privacy.getConsentString();
    final TCString consent = parseConsentString(consentString, requestLogInfo);
    final String effectiveIpAddress = maybeMaskIp(ipAddress, consent);
    if (consentStringMeansInScope && isConsentValid(consent)) {
        return Future.succeededFuture(TcfContext.builder().gdpr(GDPR_ONE).consentString(consentString).consent(consent).ipAddress(effectiveIpAddress).build());
    }
    final String gdpr = privacy.getGdpr();
    if (StringUtils.isNotEmpty(gdpr)) {
        return Future.succeededFuture(TcfContext.builder().gdpr(gdpr).consentString(consentString).consent(consent).ipAddress(effectiveIpAddress).build());
    }
    // from country
    if (country != null) {
        final Boolean inEea = isCountryInEea(country);
        return Future.succeededFuture(TcfContext.builder().gdpr(gdprFromGeo(inEea)).consentString(consentString).consent(consent).inEea(inEea).ipAddress(effectiveIpAddress).build());
    }
    // from geo location
    if (ipAddress != null && geoLocationService != null) {
        return geoLocationService.lookup(effectiveIpAddress, timeout).map(resolvedGeoInfo -> tcfContextFromGeo(resolvedGeoInfo, consentString, consent, effectiveIpAddress)).otherwise(exception -> updateGeoFailedMetricAndReturnDefaultTcfContext(exception, consentString, consent, effectiveIpAddress));
    }
    // use default
    return Future.succeededFuture(defaultTcfContext(consentString, consent, effectiveIpAddress));
}

18 Source : TcfDefinerService.java
with Apache License 2.0
from prebid

/**
 * Returns decoded {@link TCString} or {@link TCStringEmpty} in case of empty consent or error occurred.
 * <p>
 * Note: parsing TC string should not fail the entire request, but replacedume the user does not consent.
 */
private TCString parseConsentString(String consentString, RequestLogInfo requestLogInfo) {
    if (StringUtils.isBlank(consentString)) {
        metrics.updatePrivacyTcfMissingMetric();
        return TCStringEmpty.create();
    }
    final TCString tcString = decodeTcString(consentString, requestLogInfo);
    if (tcString == null) {
        metrics.updatePrivacyTcfInvalidMetric();
        return TCStringEmpty.create();
    }
    final int version = tcString.getVersion();
    metrics.updatePrivacyTcfRequestsMetric(version);
    return tcString;
}

18 Source : Tcf2Service.java
with Apache License 2.0
from prebid

public Future<Collection<VendorPermission>> permissionsFor(Set<String> bidderNames, VendorIdResolver vendorIdResolver, TCString tcfConsent, AccountGdprConfig accountGdprConfig) {
    return permissionsForInternal(vendorPermissions(bidderNames, vendorIdResolver), tcfConsent, accountGdprConfig);
}

18 Source : TcfContext.java
with Apache License 2.0
from prebid

/**
 * Internal clreplaced for holding TCF information.
 */
@Builder
@Value
public clreplaced TcfContext {

    String gdpr;

    String consentString;

    TCString consent;

    GeoInfo geoInfo;

    Boolean inEea;

    String ipAddress;

    public static TcfContext empty() {
        return builder().build();
    }
}

18 Source : VendorFieldEncoderTest.java
with Apache License 2.0
from InteractiveAdvertisingBureau

@Test
public void testForceRange() {
    BitWriter bw = createV1BitString();
    VendorFieldEncoder bfe = new VendorFieldEncoder().defaultConsent(true).emitRangeEncoding(true).setMaxVendorId(12).add(1);
    bw.write(bfe.buildV1());
    byte[] rv = bw.toByteArray();
    String str = Base64.getUrlEncoder().encodeToString(rv);
    TCString tcModel = TCString.decode(str);
    Inreplacederable vc = tcModel.getVendorConsent();
    replacedertFalse(vc.contains(1));
    replacedertTrue(vc.contains(2));
    replacedertTrue(vc.contains(12));
    replacedertFalse(vc.contains(13));
}

18 Source : VendorFieldEncoderTest.java
with Apache License 2.0
from InteractiveAdvertisingBureau

@Test
public void testEncodeDefaultConsentV1() {
    BitWriter bw = createV1BitString();
    VendorFieldEncoder bfe = new VendorFieldEncoder().defaultConsent(true).add(1).add(512);
    bw.write(bfe.buildV1());
    byte[] rv = bw.toByteArray();
    String str = Base64.getUrlEncoder().encodeToString(rv);
    TCString tcModel = TCString.decode(str);
    Inreplacederable vc = tcModel.getVendorConsent();
    replacedertFalse(vc.contains(1));
    replacedertTrue(vc.contains(2));
    replacedertFalse(vc.contains(512));
    replacedertFalse(vc.contains(513));
}

18 Source : VendorFieldEncoderTest.java
with Apache License 2.0
from InteractiveAdvertisingBureau

@Test
public void testVendorEncode() {
    BitWriter bw = createV1BitString();
    VendorFieldEncoder bfe = new VendorFieldEncoder().setMaxVendorId(32).add(1).add(25, 30, 30);
    bw.write(bfe.buildV1());
    byte[] rv = bw.toByteArray();
    String str = Base64.getUrlEncoder().encodeToString(rv);
    TCString tcModel = TCString.decode(str);
    replacedertTrue(tcModel.getVendorConsent().contains(1));
    replacedertTrue(tcModel.getVendorConsent().contains(25));
    replacedertTrue(tcModel.getVendorConsent().contains(30));
    replacedertEquals("BOOzQoAOOzQoAAPAFSENCW-AIBACBAAABCA=", str);
}

18 Source : VendorFieldEncoderTest.java
with Apache License 2.0
from InteractiveAdvertisingBureau

// TODO: make this test for V2
private void testEncodeManyVendors(int iteration, int[] vendorIds, boolean emitRange, boolean v1) {
    BitWriter bw = createV1BitString();
    VendorFieldEncoder bfe = new VendorFieldEncoder().setMaxVendorId(81).emitRangeEncoding(emitRange).add(vendorIds);
    bw.write(bfe.buildV1());
    byte[] rv = bw.toByteArray();
    String str = Base64.getUrlEncoder().encodeToString(rv);
    TCString tcModel = TCString.decode(str);
    Inreplacederable vc = tcModel.getVendorConsent();
    for (int i = 0; i < vendorIds.length; i++) {
        replacedertTrue(String.format("%d (%d): failed to find: %d", iteration, i, vendorIds[i]), vc.contains(vendorIds[i]));
    }
}

18 Source : TCStringV2EncoderTest.java
with Apache License 2.0
from InteractiveAdvertisingBureau

@Test
public void testEncodedVendorDisclosedSection() {
    String tcf = TCStringEncoder.newBuilder(encoderBuilder).addDisclosedVendors(BitSetInreplacederable.from(1, 2)).encode();
    TCString decoded = TCString.decode(tcf);
    replacedertEquals(2, tcf.split("\\.").length);
    replacedertThat(decoded.getDisclosedVendors(), matchInts(1, 2));
}

17 Source : SpecialFeaturesOneStrategyTest.java
with Apache License 2.0
from prebid

public clreplaced SpecialFeaturesOneStrategyTest {

    private static final int SPECIAL_FEATURE_ID = 1;

    @Rule
    public final MockitoRule mockitoRule = MockitoJUnit.rule();

    private SpecialFeaturesOneStrategy target;

    @Mock
    private TCString tcString;

    @Mock
    private Inreplacederable specialFeatureOptIns;

    @Before
    public void setUp() {
        given(tcString.getSpecialFeatureOptIns()).willReturn(specialFeatureOptIns);
        given(specialFeatureOptIns.contains(anyInt())).willReturn(false);
        target = new SpecialFeaturesOneStrategy();
    }

    @Test
    public void allowShouldReturnExpectedValue() {
        // given
        final PrivacyEnforcementAction privacyEnforcementAction = PrivacyEnforcementAction.restrictAll();
        // when
        target.allow(privacyEnforcementAction);
        // then
        replacedertThat(privacyEnforcementAction).isEqualTo(allowSpecialFeature());
    }

    @Test
    public void getSpecialFeatureIdShouldReturnExpectedValue() {
        // when and then
        replacedertThat(target.getSpecialFeatureId()).isEqualTo(SPECIAL_FEATURE_ID);
    }

    @Test
    public void processSpecialFeaturesStrategyShouldAllowForAllWhenIsNotEnforced() {
        // given
        final VendorPermission vendorPermission1 = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b1", PrivacyEnforcementAction.restrictAll());
        final List<VendorPermission> vendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2);
        final SpecialFeature specialFeature = SpecialFeature.of(false, emptyList());
        // when
        final Collection<VendorPermission> result = target.processSpecialFeaturesStrategy(tcString, specialFeature, vendorPermissions);
        // then
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, null, allowSpecialFeature());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b1", allowSpecialFeature());
        replacedertThat(result).usingFieldByFieldElementComparator().containsOnly(vendorPermission1Changed, vendorPermission2Changed);
        verifyZeroInteractions(specialFeatureOptIns);
    }

    @Test
    public void processSpecialFeaturesStrategyShouldAllowEmptyListWhenAllOptOutAndNoExcluded() {
        // given
        final VendorPermission vendorPermission1 = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b1", PrivacyEnforcementAction.restrictAll());
        final List<VendorPermission> vendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2);
        final SpecialFeature specialFeature = SpecialFeature.of(true, emptyList());
        // when
        final Collection<VendorPermission> result = target.processSpecialFeaturesStrategy(tcString, specialFeature, vendorPermissions);
        // then
        replacedertThat(result).usingFieldByFieldElementComparator().containsOnly(vendorPermission1, vendorPermission2);
        verify(specialFeatureOptIns).contains(SPECIAL_FEATURE_ID);
    }

    @Test
    public void processSpecialFeaturesStrategyShouldAllowOnlyExcludedWhenAllOptOutAndExcluded() {
        // given
        final VendorPermission vendorPermission1 = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b1", PrivacyEnforcementAction.restrictAll());
        final List<VendorPermission> vendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2);
        final SpecialFeature specialFeature = SpecialFeature.of(true, singletonList("b1"));
        // when
        final Collection<VendorPermission> result = target.processSpecialFeaturesStrategy(tcString, specialFeature, vendorPermissions);
        // then
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b1", allowSpecialFeature());
        replacedertThat(result).usingFieldByFieldElementComparator().containsOnly(vendorPermission1, vendorPermission2Changed);
        verify(specialFeatureOptIns).contains(SPECIAL_FEATURE_ID);
    }

    @Test
    public void processSpecialFeaturesStrategyShouldAllowExcludedAndOptIn() {
        // given
        final VendorPermission vendorPermission1 = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, "b3", PrivacyEnforcementAction.restrictAll());
        final List<VendorPermission> vendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2, vendorPermission3);
        final SpecialFeature specialFeature = SpecialFeature.of(true, singletonList("b1"));
        given(specialFeatureOptIns.contains(SPECIAL_FEATURE_ID)).willReturn(true);
        // when
        final Collection<VendorPermission> result = target.processSpecialFeaturesStrategy(tcString, specialFeature, vendorPermissions);
        // then
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, null, allowSpecialFeature());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b1", allowSpecialFeature());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, "b3", allowSpecialFeature());
        replacedertThat(result).usingFieldByFieldElementComparator().containsOnly(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed);
        verify(specialFeatureOptIns).contains(SPECIAL_FEATURE_ID);
    }

    private static PrivacyEnforcementAction allowSpecialFeature() {
        final PrivacyEnforcementAction privacyEnforcementAction = PrivacyEnforcementAction.restrictAll();
        privacyEnforcementAction.setMaskDeviceIp(false);
        privacyEnforcementAction.setMaskGeo(false);
        return privacyEnforcementAction;
    }
}

17 Source : Tcf2ServiceTest.java
with Apache License 2.0
from prebid

public clreplaced Tcf2ServiceTest extends VertxTest {

    @Rule
    public final MockitoRule mockitoRule = MockitoJUnit.rule();

    @Mock
    private BidderCatalog bidderCatalog;

    @Mock
    private VendorListServiceV2 vendorListService;

    @Mock
    private PurposeStrategy purposeStrategyOne;

    @Mock
    private PurposeStrategy purposeStrategyTwo;

    @Mock
    private PurposeStrategy purposeStrategyFour;

    @Mock
    private PurposeStrategy purposeStrategySeven;

    @Mock
    private SpecialFeaturesStrategy specialFeaturesStrategyOne;

    @Mock
    private TCString tcString;

    private Tcf2Service target;

    private Purposes purposes;

    private Purpose purpose1;

    private Purpose purpose2;

    private Purpose purpose4;

    private Purpose purpose7;

    private SpecialFeature specialFeature1;

    private SpecialFeatures specialFeatures;

    private GdprConfig gdprConfig;

    private List<PurposeStrategy> purposeStrategies;

    private List<SpecialFeaturesStrategy> specialFeaturesStrategies;

    @Before
    public void setUp() {
        given(tcString.getVendorListVersion()).willReturn(10);
        given(purposeStrategyOne.getPurpose()).willReturn(ONE);
        given(purposeStrategyTwo.getPurpose()).willReturn(TWO);
        given(purposeStrategyFour.getPurpose()).willReturn(FOUR);
        given(purposeStrategySeven.getPurpose()).willReturn(SEVEN);
        purposeStrategies = asList(purposeStrategyOne, purposeStrategyTwo, purposeStrategyFour, purposeStrategySeven);
        given(specialFeaturesStrategyOne.getSpecialFeatureId()).willReturn(1);
        specialFeaturesStrategies = singletonList(specialFeaturesStrategyOne);
        given(vendorListService.forVersion(anyInt())).willReturn(Future.succeededFuture(emptyMap()));
        initPurposes();
        initSpecialFeatures();
        initGdpr();
        target = new Tcf2Service(gdprConfig, purposeStrategies, specialFeaturesStrategies, vendorListService, bidderCatalog);
    }

    private void initPurposes() {
        purpose1 = Purpose.of(EnforcePurpose.basic, true, emptyList());
        purpose2 = Purpose.of(EnforcePurpose.no, true, emptyList());
        purpose4 = Purpose.of(EnforcePurpose.no, false, emptyList());
        purpose7 = Purpose.of(EnforcePurpose.full, false, emptyList());
        purposes = Purposes.builder().p1(purpose1).p2(purpose2).p4(purpose4).p7(purpose7).build();
    }

    private void initSpecialFeatures() {
        specialFeature1 = SpecialFeature.of(true, emptyList());
        specialFeatures = SpecialFeatures.builder().sf1(specialFeature1).build();
    }

    private void initGdpr() {
        gdprConfig = GdprConfig.builder().defaultValue("1").enabled(true).purposes(purposes).specialFeatures(specialFeatures).purposeOneTreatmentInterpretation(PurposeOneTreatmentInterpretation.ignore).build();
    }

    @Test
    public void permissionsForShouldReturnByGdprPurpose() {
        // given
        given(bidderCatalog.nameByVendorId(any())).willReturn("rubicon");
        // when
        final Future<Collection<VendorPermission>> result = target.permissionsFor(singleton(1), tcString);
        // then
        final VendorPermission expectedVendorPermission = VendorPermission.of(1, "rubicon", PrivacyEnforcementAction.restrictAll());
        replacedertThat(result).succeededWith(singletonList(expectedVendorPermission));
        final VendorPermissionWithGvl expectedVendorPermissionWitGvl = VendorPermissionWithGvl.of(expectedVendorPermission, VendorV2.empty(1));
        verifyEachPurposeStrategyReceive(singletonList(expectedVendorPermissionWitGvl));
        verifyEachSpecialFeatureStrategyReceive(singletonList(expectedVendorPermission));
        verify(bidderCatalog).nameByVendorId(1);
        verify(tcString).getVendorListVersion();
        verify(vendorListService).forVersion(10);
    }

    @Test
    public void permissionsForShouldReturnByGdprPurposeAndDowngradeToBasicTypeWhenVendorListServiceIsFailed() {
        // given
        given(vendorListService.forVersion(anyInt())).willReturn(Future.failedFuture("Bad version"));
        given(bidderCatalog.nameByVendorId(any())).willReturn("rubicon");
        // when
        final Future<Collection<VendorPermission>> result = target.permissionsFor(singleton(1), tcString);
        // then
        final VendorPermission expectedVendorPermission = VendorPermission.of(1, "rubicon", PrivacyEnforcementAction.restrictAll());
        replacedertThat(result).succeededWith(singletonList(expectedVendorPermission));
        final VendorPermissionWithGvl expectedVendorPermissionWitGvl = VendorPermissionWithGvl.of(expectedVendorPermission, VendorV2.empty(1));
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = singletonList(expectedVendorPermissionWitGvl);
        verify(purposeStrategyOne).processTypePurposeStrategy(tcString, purpose1, vendorPermissionWithGvls, true);
        verify(purposeStrategyTwo).processTypePurposeStrategy(tcString, purpose2, vendorPermissionWithGvls, true);
        verify(purposeStrategyFour).processTypePurposeStrategy(tcString, purpose4, vendorPermissionWithGvls, true);
        final Purpose expectedDowngradedPurpose = Purpose.of(EnforcePurpose.basic, purpose7.getEnforceVendors(), purpose1.getVendorExceptions());
        verify(purposeStrategySeven).processTypePurposeStrategy(tcString, expectedDowngradedPurpose, vendorPermissionWithGvls, true);
        verifyEachSpecialFeatureStrategyReceive(singletonList(expectedVendorPermission));
        verify(bidderCatalog).nameByVendorId(1);
        verify(tcString).getVendorListVersion();
        verify(vendorListService).forVersion(10);
    }

    @Test
    public void permissionsForShouldMergeAccountPurposes() {
        // given
        final Purpose accountPurposeOne = Purpose.of(EnforcePurpose.full, false, singletonList("test"));
        final Purposes accountPurposes = Purposes.builder().p1(accountPurposeOne).build();
        final AccountGdprConfig accountGdprConfig = AccountGdprConfig.builder().purposes(accountPurposes).build();
        final VendorIdResolver vendorIdResolver = mock(VendorIdResolver.clreplaced);
        given(vendorIdResolver.resolve(anyString())).willReturn(null);
        // when
        final Future<Collection<VendorPermission>> result = target.permissionsFor(singleton("b1"), vendorIdResolver, tcString, accountGdprConfig);
        // then
        final VendorPermission expectedVendorPermission = VendorPermission.of(null, "b1", PrivacyEnforcementAction.restrictAll());
        replacedertThat(result).succeededWith(singletonList(expectedVendorPermission));
        verify(purposeStrategyOne).processTypePurposeStrategy(tcString, accountPurposeOne, singletonList(VendorPermissionWithGvl.of(expectedVendorPermission, VendorV2.empty(null))), false);
        verify(tcString).getVendorListVersion();
        verify(vendorListService).forVersion(10);
    }

    @Test
    public void permissionsForShouldMergeAccountSpecialFeatures() {
        // given
        final SpecialFeature accountSpecialFeatureOne = SpecialFeature.of(false, emptyList());
        final SpecialFeatures specialFeatures = SpecialFeatures.builder().sf1(accountSpecialFeatureOne).build();
        final AccountGdprConfig accountGdprConfig = AccountGdprConfig.builder().specialFeatures(specialFeatures).build();
        final VendorIdResolver vendorIdResolver = mock(VendorIdResolver.clreplaced);
        given(vendorIdResolver.resolve(anyString())).willReturn(null);
        // when
        final Future<Collection<VendorPermission>> result = target.permissionsFor(singleton("b1"), vendorIdResolver, tcString, accountGdprConfig);
        // then
        final VendorPermission expectedVendorPermission = VendorPermission.of(null, "b1", PrivacyEnforcementAction.restrictAll());
        replacedertThat(result).succeededWith(singletonList(expectedVendorPermission));
        verify(specialFeaturesStrategyOne).processSpecialFeaturesStrategy(tcString, accountSpecialFeatureOne, singletonList(expectedVendorPermission));
    }

    @Test
    public void permissionsForShouldReturnBidderNamesResult() {
        // given
        final VendorIdResolver vendorIdResolver = mock(VendorIdResolver.clreplaced);
        given(vendorIdResolver.resolve(eq("b1"))).willReturn(1);
        given(vendorIdResolver.resolve(eq("b2"))).willReturn(null);
        // when
        final Future<Collection<VendorPermission>> result = target.permissionsFor(new HashSet<>(asList("b1", "b2")), vendorIdResolver, tcString, null);
        // then
        final VendorPermission expectedVendorPermission1 = VendorPermission.of(1, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission expectedVendorPermission2 = VendorPermission.of(null, "b2", PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl expectedVendorPermissionWitGvl1 = VendorPermissionWithGvl.of(expectedVendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl expectedVendorPermissionWitGvl2 = VendorPermissionWithGvl.of(expectedVendorPermission2, VendorV2.empty(null));
        replacedertThat(result).succeededWith(asList(expectedVendorPermission2, expectedVendorPermission1));
        verifyEachPurposeStrategyReceive(asList(expectedVendorPermissionWitGvl2, expectedVendorPermissionWitGvl1));
        verifyEachSpecialFeatureStrategyReceive(asList(expectedVendorPermission2, expectedVendorPermission1));
        verify(vendorIdResolver, times(2)).resolve(anyString());
        verify(tcString).getVendorListVersion();
    }

    @Test
    public void permissionsForShouldReturnVendorIdsResult() {
        // given
        given(bidderCatalog.nameByVendorId(eq(1))).willReturn("b1");
        // when
        final Future<Collection<VendorPermission>> result = target.permissionsFor(new HashSet<>(asList(1, 2)), tcString);
        // then
        final VendorPermission expectedVendorPermission1 = VendorPermission.of(1, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission expectedVendorPermission2 = VendorPermission.of(2, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl expectedVendorPermissionWitGvl1 = VendorPermissionWithGvl.of(expectedVendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl expectedVendorPermissionWitGvl2 = VendorPermissionWithGvl.of(expectedVendorPermission2, VendorV2.empty(2));
        replacedertThat(result).succeededWith(asList(expectedVendorPermission1, expectedVendorPermission2));
        verifyEachPurposeStrategyReceive(asList(expectedVendorPermissionWitGvl1, expectedVendorPermissionWitGvl2));
        verifyEachSpecialFeatureStrategyReceive(asList(expectedVendorPermission1, expectedVendorPermission2));
        verify(bidderCatalog, times(2)).nameByVendorId(anyInt());
        verify(tcString).getVendorListVersion();
        verifyNoMoreInteractions(bidderCatalog);
    }

    @Test
    public void permissionsForShouldReturnAllDeniedWhenP1TIIsNoAccessAllowed() {
        // given
        given(bidderCatalog.nameByVendorId(any())).willReturn("rubicon");
        given(tcString.getPurposeOneTreatment()).willReturn(true);
        final GdprConfig gdprConfig = GdprConfig.builder().purposes(purposes).purposeOneTreatmentInterpretation(PurposeOneTreatmentInterpretation.noAccessAllowed).build();
        target = new Tcf2Service(gdprConfig, purposeStrategies, specialFeaturesStrategies, vendorListService, bidderCatalog);
        // when
        final Future<Collection<VendorPermission>> result = target.permissionsFor(singleton(1), tcString);
        // then
        replacedertThat(result).succeededWith(singletonList(VendorPermission.of(1, "rubicon", PrivacyEnforcementAction.restrictAll())));
        verify(purposeStrategyOne, never()).processTypePurposeStrategy(any(), any(), anyCollection(), anyBoolean());
        verify(purposeStrategyTwo).processTypePurposeStrategy(any(), any(), anyCollection(), anyBoolean());
        verify(purposeStrategySeven).processTypePurposeStrategy(any(), any(), anyCollection(), anyBoolean());
        verify(purposeStrategyFour).processTypePurposeStrategy(any(), any(), anyCollection(), anyBoolean());
        verify(specialFeaturesStrategyOne).processSpecialFeaturesStrategy(any(), any(), anyCollection());
    }

    @Test
    public void permissionsForShouldAllowAllWhenP1TIIsAccessAllowed() {
        // given
        given(bidderCatalog.nameByVendorId(any())).willReturn("rubicon");
        given(tcString.getPurposeOneTreatment()).willReturn(true);
        final GdprConfig gdprConfig = GdprConfig.builder().purposes(purposes).purposeOneTreatmentInterpretation(PurposeOneTreatmentInterpretation.accessAllowed).build();
        target = new Tcf2Service(gdprConfig, purposeStrategies, specialFeaturesStrategies, vendorListService, bidderCatalog);
        // when
        target.permissionsFor(singleton(1), tcString);
        // then
        verify(purposeStrategyOne, never()).processTypePurposeStrategy(any(), any(), anyCollection(), anyBoolean());
        verify(purposeStrategyOne).allow(any());
        verify(purposeStrategyTwo).processTypePurposeStrategy(any(), any(), anyCollection(), anyBoolean());
        verify(purposeStrategySeven).processTypePurposeStrategy(any(), any(), anyCollection(), anyBoolean());
        verify(purposeStrategyFour).processTypePurposeStrategy(any(), any(), anyCollection(), anyBoolean());
        verify(specialFeaturesStrategyOne).processSpecialFeaturesStrategy(any(), any(), anyCollection());
    }

    @Test
    public void permissionsForShouldNotAllowAllWhenP1TIsFalseAndP1TIIsAccessAllowed() {
        // given
        given(bidderCatalog.nameByVendorId(any())).willReturn("rubicon");
        given(tcString.getPurposeOneTreatment()).willReturn(false);
        final GdprConfig gdprConfig = GdprConfig.builder().purposes(purposes).purposeOneTreatmentInterpretation(PurposeOneTreatmentInterpretation.accessAllowed).build();
        target = new Tcf2Service(gdprConfig, purposeStrategies, specialFeaturesStrategies, vendorListService, bidderCatalog);
        // when
        target.permissionsFor(singleton(1), tcString);
        // then
        verify(purposeStrategyOne, never()).allow(any());
        verify(purposeStrategyOne).processTypePurposeStrategy(any(), any(), anyCollection(), anyBoolean());
        verify(purposeStrategyTwo).processTypePurposeStrategy(any(), any(), anyCollection(), anyBoolean());
        verify(purposeStrategySeven).processTypePurposeStrategy(any(), any(), anyCollection(), anyBoolean());
        verify(purposeStrategyFour).processTypePurposeStrategy(any(), any(), anyCollection(), anyBoolean());
        verify(specialFeaturesStrategyOne).processSpecialFeaturesStrategy(any(), any(), anyCollection());
    }

    public void verifyEachPurposeStrategyReceive(List<VendorPermissionWithGvl> vendorPermissionWithGvls) {
        verify(purposeStrategyOne).processTypePurposeStrategy(tcString, purpose1, vendorPermissionWithGvls, false);
        verify(purposeStrategyTwo).processTypePurposeStrategy(tcString, purpose2, vendorPermissionWithGvls, false);
        verify(purposeStrategyFour).processTypePurposeStrategy(tcString, purpose4, vendorPermissionWithGvls, false);
        verify(purposeStrategySeven).processTypePurposeStrategy(tcString, purpose7, vendorPermissionWithGvls, false);
    }

    public void verifyEachSpecialFeatureStrategyReceive(List<VendorPermission> vendorPermission) {
        verify(specialFeaturesStrategyOne).processSpecialFeaturesStrategy(tcString, specialFeature1, vendorPermission);
    }
}

17 Source : PurposeTwoBasicEnforcePurposeStrategy.java
with Apache License 2.0
from prebid

public Collection<VendorPermission> allowedByTypeStrategy(Purpose purpose, TCString vendorConsent, Collection<VendorPermissionWithGvl> vendorsForPurpose, Collection<VendorPermissionWithGvl> excludedVendors, boolean isEnforceVendors) {
    logger.debug("Basic strategy used fo purpose {0}", purpose);
    final List<VendorPermission> allowedVendorPermissions = vendorsForPurpose.stream().map(VendorPermissionWithGvl::getVendorPermission).filter(vendorPermission -> vendorPermission.getVendorId() != null).filter(vendorPermission -> isAllowedBySimpleConsentOrPurposeLI(purpose, vendorPermission.getVendorId(), isEnforceVendors, vendorConsent)).collect(Collectors.toList());
    return CollectionUtils.union(allowedVendorPermissions, toVendorPermissions(excludedVendors));
}

17 Source : BasicEnforcePurposeStrategy.java
with Apache License 2.0
from prebid

public Collection<VendorPermission> allowedByTypeStrategy(Purpose purpose, TCString vendorConsent, Collection<VendorPermissionWithGvl> vendorsForPurpose, Collection<VendorPermissionWithGvl> excludedVendors, boolean isEnforceVendors) {
    logger.debug("Basic strategy used for purpose {0}", purpose);
    final List<VendorPermission> allowedVendorPermissions = vendorsForPurpose.stream().map(VendorPermissionWithGvl::getVendorPermission).filter(vendorPermission -> vendorPermission.getVendorId() != null).filter(vendorPermission -> isAllowedBySimpleConsent(purpose, vendorPermission.getVendorId(), isEnforceVendors, vendorConsent)).collect(Collectors.toList());
    return CollectionUtils.union(allowedVendorPermissions, toVendorPermissions(excludedVendors));
}

17 Source : TcfDefinerService.java
with Apache License 2.0
from prebid

private <T> Future<TcfResponse<T>> resultForInternal(TcfContext tcfContext, Function<String, Future<TcfResponse<T>>> allowAllTcfResponseCreator, BiFunction<TCString, String, Future<TcfResponse<T>>> tcf2Strategy, BiFunction<String, String, Future<TcfResponse<T>>> gdprStrategy) {
    final GeoInfo geoInfo = tcfContext.getGeoInfo();
    final String country = geoInfo != null ? geoInfo.getCountry() : null;
    if (!inScope(tcfContext)) {
        return allowAllTcfResponseCreator.apply(country);
    }
    final TCString consent = tcfContext.getConsent();
    return consent.getVersion() == 2 ? tcf2Strategy.apply(consent, country) : gdprStrategy.apply(tcfContext.getConsentString(), country);
}

17 Source : TCStringV2EncoderTest.java
with Apache License 2.0
from InteractiveAdvertisingBureau

@Test
public void testToTCString() {
    TCString tcStr = TCString.decode("COtybn4PA_zT4KjACBENAPCIAEBAAECAAIAAAAAAAAAA");
    TCStringEncoder.Builder b = TCStringEncoder.newBuilder(tcStr);
    TCString tcStr1 = b.toTCString();
    replacedertEquals(tcStr, tcStr1);
    b.addAllowedVendors(BitSetInreplacederable.from(tcStr.getAllowedVendors())).addAllowedVendors(400);
    replacedertNotEquals(tcStr, b.toTCString());
}

17 Source : TCStringV2EncoderTest.java
with Apache License 2.0
from InteractiveAdvertisingBureau

@Test
public void testEncodingUsingTcfStringWithPublisherRestrictions() {
    String tcStr = "CO9ZBNoO9ZBNoAOACAENAnCsAP_AAH_AACiQFvNR6RBUJWjjMCAZg7BAAQQLIBADAAwAhAQIAAAAQIAEoBgGKEEQnBUgAAAACAAgAAYAAAAkFCAAAQAAAAAAgQIMQECICwBAAJAAgEEQQwAQAARMAgFSEQAAREwAEC0CARAAqAJAhCAAEgRAgAIAEAAgAgAAIQAgAAAAAAAACUAQBFCAAAAgAAAAAAAAQAAEAAAAAAAAAAAAAAAAAAIAEAAAABoAAAAAAQCAAAQAIAAACAAAIAAAAAAIAYaAQACoAJkAVQBWAFIANIAcQCbAE7CIBAAKgAmQBVAFYAUgArgBxAJsATsKgDAAqACYAI4AUgA4gE2A";
    TCString tcString = TCString.decode(tcStr);
    replacedertNotNull(tcString.getPublisherRestrictions());
    replacedertEquals(3, tcString.getPublisherRestrictions().size());
    TCStringEncoder.Builder tcStringEncoder = TCStringEncoder.newBuilder(tcString);
    String tcStrWithPublisherRestrictions = tcStringEncoder.encode();
    replacedertNotNull(TCString.decode(tcStrWithPublisherRestrictions).getPublisherRestrictions());
    replacedertEquals(3, TCString.decode(tcStrWithPublisherRestrictions).getPublisherRestrictions().size());
    replacedertEquals(tcStr, tcStrWithPublisherRestrictions);
}

17 Source : BitReaderTest.java
with Apache License 2.0
from InteractiveAdvertisingBureau

@Test(expected = ByteParseException.clreplaced)
public void testReadBeyondBuffer() {
    // bit pattern: 0000011
    TCString tcString = TCString.decode("Bg");
    tcString.getCreated();
}

16 Source : PurposeTwoBasicEnforcePurposeStrategyTest.java
with Apache License 2.0
from prebid

public clreplaced PurposeTwoBasicEnforcePurposeStrategyTest {

    private static final Purpose PURPOSE = Purpose.ONE;

    @Rule
    public final MockitoRule mockitoRule = MockitoJUnit.rule();

    private PurposeTwoBasicEnforcePurposeStrategy target;

    @Mock
    private TCString tcString;

    @Mock
    private Inreplacederable allowedVendors;

    @Mock
    private Inreplacederable allowedVendorsLI;

    @Mock
    private Inreplacederable purposesConsent;

    @Mock
    private Inreplacederable purposesLI;

    @Before
    public void setUp() {
        given(tcString.getVendorConsent()).willReturn(allowedVendors);
        given(tcString.getVendorLegitimateInterest()).willReturn(allowedVendorsLI);
        given(tcString.getPurposesConsent()).willReturn(purposesConsent);
        given(tcString.getPurposesLITransparency()).willReturn(purposesLI);
        given(allowedVendors.contains(anyInt())).willReturn(false);
        given(allowedVendorsLI.contains(anyInt())).willReturn(false);
        given(purposesConsent.contains(anyInt())).willReturn(false);
        given(purposesLI.contains(anyInt())).willReturn(false);
        target = new PurposeTwoBasicEnforcePurposeStrategy();
    }

    @Test
    public void allowedByTypeStrategyShouldReturnEmptyListWhenVendorIsNotAllowedAndVendorIsNotEnforced() {
        // given
        final VendorPermission vendorPermission = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl = VendorPermissionWithGvl.of(vendorPermission, VendorV2.empty(1));
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = singletonList(vendorPermissionWitGvl);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPermissionWithGvls, emptyList(), false);
        // then
        replacedertThat(result).isEmpty();
    }

    @Test
    public void allowedByTypeStrategyShouldReturnEmptyListWhenVendorIsNotAllowedAndVendorEnforced() {
        // given
        final VendorPermission vendorPermission = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl = VendorPermissionWithGvl.of(vendorPermission, VendorV2.empty(1));
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = singletonList(vendorPermissionWitGvl);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPermissionWithGvls, emptyList(), true);
        // then
        replacedertThat(result).isEmpty();
    }

    @Test
    public void allowedByTypeStrategyShouldReturnExpectedValueWhenVendorIsAllowedAndVendorEnforced() {
        // given
        final VendorPermission vendorPermission = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl = VendorPermissionWithGvl.of(vendorPermission, VendorV2.empty(1));
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = singletonList(vendorPermissionWitGvl);
        given(allowedVendors.contains(anyInt())).willReturn(true);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPermissionWithGvls, emptyList(), true);
        // then
        replacedertThat(result).isEmpty();
    }

    @Test
    public void allowedByTypeStrategyShouldReturnExpectedValueWhenVendorIsAllowedAndVendorIsNotEnforced() {
        // given
        final VendorPermission vendorPermission = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl = VendorPermissionWithGvl.of(vendorPermission, VendorV2.empty(1));
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = singletonList(vendorPermissionWitGvl);
        given(allowedVendors.contains(anyInt())).willReturn(true);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPermissionWithGvls, emptyList(), false);
        // then
        replacedertThat(result).isEmpty();
    }

    @Test
    public void allowedByTypeStrategyShouldReturnExpectedValueWhenVendorLIIsAllowedAndVendorEnforced() {
        // given
        final VendorPermission vendorPermission = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl = VendorPermissionWithGvl.of(vendorPermission, VendorV2.empty(1));
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = singletonList(vendorPermissionWitGvl);
        given(allowedVendorsLI.contains(anyInt())).willReturn(true);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPermissionWithGvls, emptyList(), true);
        // then
        replacedertThat(result).isEmpty();
    }

    @Test
    public void allowedByTypeStrategyShouldReturnExpectedValueWhenVendorLIIsAllowedAndVendorIsNotEnforced() {
        // given
        final VendorPermission vendorPermission = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl = VendorPermissionWithGvl.of(vendorPermission, VendorV2.empty(1));
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = singletonList(vendorPermissionWitGvl);
        given(allowedVendorsLI.contains(anyInt())).willReturn(true);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPermissionWithGvls, emptyList(), false);
        // then
        replacedertThat(result).isEmpty();
    }

    @Test
    public void allowedByTypeStrategyShouldReturnExpectedValueWhenPurposeLIAndPurposeIsAllowedAndVendorIsNotEnforced() {
        // given
        final VendorPermission vendorPermission = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl = VendorPermissionWithGvl.of(vendorPermission, VendorV2.empty(1));
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = singletonList(vendorPermissionWitGvl);
        given(purposesConsent.contains(anyInt())).willReturn(true);
        given(purposesLI.contains(anyInt())).willReturn(true);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPermissionWithGvls, emptyList(), false);
        // then
        replacedertThat(result).usingFieldByFieldElementComparator().containsOnly(vendorPermission);
    }

    @Test
    public void allowedByTypeStrategyShouldReturnExpectedValueWhenPurposeLIAndPurposeIsAllowedAndVendorEnforced() {
        // given
        final VendorPermission vendorPermission = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl = VendorPermissionWithGvl.of(vendorPermission, VendorV2.empty(1));
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = singletonList(vendorPermissionWitGvl);
        given(purposesConsent.contains(anyInt())).willReturn(true);
        given(purposesLI.contains(anyInt())).willReturn(true);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPermissionWithGvls, emptyList(), true);
        // then
        replacedertThat(result).usingFieldByFieldElementComparator().containsOnly(vendorPermission);
    }

    @Test
    public void allowedByTypeStrategyShouldReturnExpectedValueWhenPurposeLIAndVendorIsAllowedAndVendorIsNotEnforced() {
        // given
        final VendorPermission vendorPermission1 = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2);
        given(allowedVendors.contains(anyInt())).willReturn(true);
        given(purposesLI.contains(PURPOSE.code())).willReturn(true);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPermissionWithGvls, emptyList(), false);
        // then
        replacedertThat(result).usingFieldByFieldElementComparator().containsOnly(vendorPermission1, vendorPermission2);
    }

    @Test
    public void allowedByTypeStrategyShouldReturnExpectedValueWhenPurposeAndVendorLIIsAllowedAndVendorIsNotEnforced() {
        // given
        final VendorPermission vendorPermission1 = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2);
        given(allowedVendorsLI.contains(anyInt())).willReturn(true);
        given(purposesConsent.contains(PURPOSE.code())).willReturn(true);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPermissionWithGvls, emptyList(), false);
        // then
        replacedertThat(result).usingFieldByFieldElementComparator().containsOnly(vendorPermission1, vendorPermission2);
    }

    @Test
    public void allowedByTypeStrategyShouldReturnExcludedVendors() {
        // given
        final VendorPermission vendorPermission1 = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, singleton(vendorPermissionWitGvl1), singleton(vendorPermissionWitGvl2), true);
        // then
        replacedertThat(result).usingFieldByFieldElementComparator().containsOnly(vendorPermission2);
    }
}

16 Source : NoEnforcePurposeStrategyTest.java
with Apache License 2.0
from prebid

public clreplaced NoEnforcePurposeStrategyTest {

    private static final Purpose PURPOSE = Purpose.ONE;

    @Rule
    public final MockitoRule mockitoRule = MockitoJUnit.rule();

    private NoEnforcePurposeStrategy target;

    @Mock
    private TCString tcString;

    @Mock
    private Inreplacederable allowedVendors;

    @Mock
    private Inreplacederable allowedVendorsLI;

    @Before
    public void setUp() {
        given(tcString.getVendorConsent()).willReturn(allowedVendors);
        given(tcString.getVendorLegitimateInterest()).willReturn(allowedVendorsLI);
        given(allowedVendors.contains(anyInt())).willReturn(false);
        given(allowedVendorsLI.contains(anyInt())).willReturn(false);
        target = new NoEnforcePurposeStrategy();
    }

    @Test
    public void allowedByTypeStrategyShouldReturnExpectedListWhenVendorIsNotAllowedAndVendorIsNotEnforced() {
        // given
        final VendorPermission vendorPermission = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl = VendorPermissionWithGvl.of(vendorPermission, VendorV2.empty(1));
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = singletonList(vendorPermissionWitGvl);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPermissionWithGvls, emptyList(), false);
        // then
        replacedertThat(result).usingFieldByFieldElementComparator().containsOnly(vendorPermission);
    }

    @Test
    public void allowedByTypeStrategyShouldReturnEmptyListWhenVendorIsNotAllowedAndVendorEnforced() {
        // given
        final VendorPermission vendorPermission = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl = VendorPermissionWithGvl.of(vendorPermission, VendorV2.empty(1));
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = singletonList(vendorPermissionWitGvl);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPermissionWithGvls, emptyList(), true);
        // then
        replacedertThat(result).isEmpty();
    }

    @Test
    public void allowedByTypeStrategyShouldReturnExpectedValueWhenVendorIsAllowedAndVendorEnforced() {
        // given
        final VendorPermission vendorPermission = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl = VendorPermissionWithGvl.of(vendorPermission, VendorV2.empty(1));
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = singletonList(vendorPermissionWitGvl);
        given(allowedVendors.contains(anyInt())).willReturn(true);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPermissionWithGvls, emptyList(), true);
        // then
        replacedertThat(result).usingFieldByFieldElementComparator().containsOnly(vendorPermission);
    }

    @Test
    public void allowedByTypeStrategyShouldReturnExpectedValueWhenVendorIsAllowedAndVendorIsNotEnforced() {
        // given
        final VendorPermission vendorPermission = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl = VendorPermissionWithGvl.of(vendorPermission, VendorV2.empty(1));
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = singletonList(vendorPermissionWitGvl);
        given(allowedVendors.contains(anyInt())).willReturn(true);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPermissionWithGvls, emptyList(), false);
        // then
        replacedertThat(result).usingFieldByFieldElementComparator().containsOnly(vendorPermission);
    }

    @Test
    public void allowedByTypeStrategyShouldReturnExpectedValueWhenVendorLIIsAllowedAndVendorEnforced() {
        // given
        final VendorPermission vendorPermission = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl = VendorPermissionWithGvl.of(vendorPermission, VendorV2.empty(1));
        final List<VendorPermissionWithGvl> vendorPurposeWithGvls = singletonList(vendorPermissionWitGvl);
        given(allowedVendorsLI.contains(anyInt())).willReturn(true);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPurposeWithGvls, emptyList(), true);
        // then
        replacedertThat(result).usingFieldByFieldElementComparator().containsOnly(vendorPermission);
    }

    @Test
    public void allowedByTypeStrategyShouldReturnExpectedValueWhenVendorLIIsAllowedAndVendorIsNotEnforced() {
        // given
        final VendorPermission vendorPermission = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl = VendorPermissionWithGvl.of(vendorPermission, VendorV2.empty(1));
        final List<VendorPermissionWithGvl> vendorPurposeWithGvls = singletonList(vendorPermissionWitGvl);
        given(allowedVendorsLI.contains(anyInt())).willReturn(true);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPurposeWithGvls, emptyList(), false);
        // then
        replacedertThat(result).usingFieldByFieldElementComparator().containsOnly(vendorPermission);
    }

    @Test
    public void allowedByTypeStrategyShouldReturnExpectedValueWhenVendorIsAllowedForFirstAndVendorIsNotEnforced() {
        // given
        final VendorPermission vendorPermission1 = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(1));
        final List<VendorPermissionWithGvl> vendorPurposeWithGvls = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2);
        given(allowedVendors.contains(eq(1))).willReturn(true);
        given(allowedVendors.contains(eq(2))).willReturn(false);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPurposeWithGvls, emptyList(), false);
        // then
        replacedertThat(result).usingFieldByFieldElementComparator().containsOnly(vendorPermission1, vendorPermission2);
    }

    @Test
    public void allowedByTypeStrategyShouldReturnExpectedValueWhenVendorIsAllowedForFirstAndVendorIsEnforced() {
        // given
        final VendorPermission vendorPermission1 = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(1));
        final List<VendorPermissionWithGvl> vendorPurposeWithGvls = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2);
        given(allowedVendors.contains(eq(1))).willReturn(true);
        given(allowedVendors.contains(eq(2))).willReturn(false);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPurposeWithGvls, emptyList(), true);
        // then
        replacedertThat(result).usingFieldByFieldElementComparator().containsOnly(vendorPermission1);
    }

    @Test
    public void allowedByTypeStrategyShouldReturnExpectedValueWhenPurposeAndVendorLIIsAllowedAndVendorIsNotEnforced() {
        // given
        final VendorPermission vendorPermission1 = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(1));
        final List<VendorPermissionWithGvl> vendorPurposeWithGvls = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2);
        given(allowedVendorsLI.contains(eq(1))).willReturn(true);
        given(allowedVendorsLI.contains(eq(2))).willReturn(false);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPurposeWithGvls, emptyList(), false);
        // then
        replacedertThat(result).usingFieldByFieldElementComparator().containsOnly(vendorPermission1, vendorPermission2);
    }

    @Test
    public void allowedByTypeStrategyShouldReturnExpectedValueWhenPurposeAndVendorLIIsAllowedAndVendorIsEnforced() {
        // given
        final VendorPermission vendorPermission1 = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(1));
        final List<VendorPermissionWithGvl> vendorPurposeWithGvls = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2);
        given(allowedVendorsLI.contains(eq(1))).willReturn(true);
        given(allowedVendorsLI.contains(eq(2))).willReturn(false);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPurposeWithGvls, emptyList(), true);
        // then
        replacedertThat(result).usingFieldByFieldElementComparator().containsOnly(vendorPermission1);
    }

    @Test
    public void allowedByTypeStrategyShouldReturnExcludedVendors() {
        // given
        final VendorPermission vendorPermission1 = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(1));
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, singletonList(vendorPermissionWitGvl1), singletonList(vendorPermissionWitGvl2), true);
        // then
        replacedertThat(result).usingFieldByFieldElementComparator().containsOnly(vendorPermission2);
    }
}

16 Source : FullEnforcePurposeStrategyTest.java
with Apache License 2.0
from prebid

public clreplaced FullEnforcePurposeStrategyTest {

    private static final Purpose PURPOSE = Purpose.ONE;

    @Rule
    public final MockitoRule mockitoRule = MockitoJUnit.rule();

    private FullEnforcePurposeStrategy target;

    @Mock
    private TCString tcString;

    @Mock
    private Inreplacederable allowedVendors;

    @Mock
    private Inreplacederable allowedVendorsLI;

    @Mock
    private Inreplacederable purposesConsent;

    @Mock
    private Inreplacederable purposesLI;

    @Mock
    private Inreplacederable vendorIds;

    @Mock
    private PublisherRestriction publisherRestriction;

    @Before
    public void setUp() {
        given(tcString.getVendorConsent()).willReturn(allowedVendors);
        given(tcString.getVendorLegitimateInterest()).willReturn(allowedVendorsLI);
        given(tcString.getPurposesConsent()).willReturn(purposesConsent);
        given(tcString.getPurposesLITransparency()).willReturn(purposesLI);
        given(tcString.getPublisherRestrictions()).willReturn(singletonList(publisherRestriction));
        given(publisherRestriction.getPurposeId()).willReturn(PURPOSE.code());
        given(publisherRestriction.getVendorIds()).willReturn(vendorIds);
        given(publisherRestriction.getRestrictionType()).willReturn(RestrictionType.UNDEFINED);
        given(allowedVendors.contains(anyInt())).willReturn(false);
        given(allowedVendorsLI.contains(anyInt())).willReturn(false);
        given(purposesConsent.contains(anyInt())).willReturn(false);
        given(purposesLI.contains(anyInt())).willReturn(false);
        given(vendorIds.contains(anyInt())).willReturn(false);
        target = new FullEnforcePurposeStrategy();
    }

    @Test
    public void shouldReturnOnlyExcludedAllowedWhenMultiplePublisherRestrictionsProvided() {
        // given
        final Inreplacederable requireConsenreplacederable = mock(Inreplacederable.clreplaced);
        final PublisherRestriction publisherRestriction1 = new PublisherRestriction(PURPOSE.code(), RestrictionType.REQUIRE_CONSENT, requireConsenreplacederable);
        given(requireConsenreplacederable.spliterator()).willReturn(singletonList(1).spliterator());
        final Inreplacederable notAllowedIterable = mock(Inreplacederable.clreplaced);
        final PublisherRestriction publisherRestriction2 = new PublisherRestriction(PURPOSE.code(), RestrictionType.NOT_ALLOWED, notAllowedIterable);
        given(notAllowedIterable.spliterator()).willReturn(Arrays.asList(4, 2).spliterator());
        given(tcString.getPublisherRestrictions()).willReturn(Arrays.asList(publisherRestriction1, publisherRestriction2));
        final VendorPermission vendorPermission1 = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission4 = VendorPermission.of(4, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission5 = VendorPermission.of(5, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl requireConsentPermission = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl notAllowedPermission = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl excludedNotMentionedPermission = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final VendorPermissionWithGvl excludedNotAllowedPermission = VendorPermissionWithGvl.of(vendorPermission4, VendorV2.empty(4));
        final VendorPermissionWithGvl notMentionedPermission = VendorPermissionWithGvl.of(vendorPermission5, VendorV2.empty(5));
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, Arrays.asList(requireConsentPermission, notAllowedPermission, notMentionedPermission), Arrays.asList(excludedNotMentionedPermission, excludedNotAllowedPermission), true);
        // then
        replacedertThat(result).usingFieldByFieldElementComparator().containsOnly(vendorPermission3);
    }

    @Test
    public void shouldReturnExpectedWhenMultiplePublisherRestrictionsProvided() {
        // given
        final Inreplacederable requireConsenreplacederable = mock(Inreplacederable.clreplaced);
        final PublisherRestriction publisherRestriction1 = new PublisherRestriction(PURPOSE.code(), RestrictionType.REQUIRE_CONSENT, requireConsenreplacederable);
        given(requireConsenreplacederable.spliterator()).willReturn(singletonList(1).spliterator());
        given(requireConsenreplacederable.contains(eq(1))).willReturn(true);
        final Inreplacederable notAllowedIterable = mock(Inreplacederable.clreplaced);
        final PublisherRestriction publisherRestriction2 = new PublisherRestriction(PURPOSE.code(), RestrictionType.NOT_ALLOWED, notAllowedIterable);
        given(notAllowedIterable.spliterator()).willReturn(Arrays.asList(4, 2).spliterator());
        given(notAllowedIterable.contains(eq(4))).willReturn(true);
        given(notAllowedIterable.contains(eq(2))).willReturn(true);
        given(tcString.getPublisherRestrictions()).willReturn(Arrays.asList(publisherRestriction1, publisherRestriction2));
        final VendorPermission vendorPermission1 = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission4 = VendorPermission.of(4, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission5 = VendorPermission.of(5, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl requireConsentPermission = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.builder().id(1).purposes(EnumSet.of(PURPOSE)).build());
        final VendorPermissionWithGvl notAllowedPermission = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.builder().id(2).purposes(EnumSet.of(PURPOSE)).build());
        final VendorPermissionWithGvl excludedNotMentionedPermission = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.builder().id(3).purposes(EnumSet.of(PURPOSE)).build());
        final VendorPermissionWithGvl excludedNotAllowedPermission = VendorPermissionWithGvl.of(vendorPermission4, VendorV2.builder().id(4).purposes(EnumSet.of(PURPOSE)).build());
        final VendorPermissionWithGvl notMentionedPermission = VendorPermissionWithGvl.of(vendorPermission5, VendorV2.builder().id(5).purposes(EnumSet.of(PURPOSE)).build());
        given(purposesConsent.contains(anyInt())).willReturn(true);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, Arrays.asList(requireConsentPermission, notAllowedPermission, notMentionedPermission), Arrays.asList(excludedNotMentionedPermission, excludedNotAllowedPermission), false);
        // then
        replacedertThat(result).usingFieldByFieldElementComparator().containsOnly(vendorPermission1, vendorPermission3, vendorPermission5);
    }

    @Test
    public void shouldAllowWhenInGvlPurposeAndPurposeConsentAllowed() {
        // given
        final VendorV2 vendorGvl = VendorV2.builder().purposes(EnumSet.of(PURPOSE)).flexiblePurposes(EnumSet.noneOf(Purpose.clreplaced)).build();
        final VendorPermission vendorPermission = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl = VendorPermissionWithGvl.of(vendorPermission, vendorGvl);
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = singletonList(vendorPermissionWitGvl);
        given(purposesConsent.contains(anyInt())).willReturn(true);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPermissionWithGvls, emptyList(), false);
        // then
        replacedertThat(result).usingFieldByFieldElementComparator().containsOnly(vendorPermission);
        verify(purposesConsent).contains(PURPOSE.code());
    }

    @Test
    public void shouldEmptyWhenInGvlPurposeAndPurposeLIAllowed() {
        // given
        final VendorV2 vendorGvl = VendorV2.builder().purposes(EnumSet.of(PURPOSE)).flexiblePurposes(EnumSet.noneOf(Purpose.clreplaced)).build();
        final VendorPermission vendorPermission = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl = VendorPermissionWithGvl.of(vendorPermission, vendorGvl);
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = singletonList(vendorPermissionWitGvl);
        given(purposesLI.contains(anyInt())).willReturn(true);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPermissionWithGvls, emptyList(), false);
        // then
        replacedertThat(result).isEmpty();
        verifyZeroInteractions(purposesLI);
    }

    @Test
    public void shouldAllowWhenInGvlPurposeAndPurposeConsentAllowedAndVendorConsentAllowedAndEnforced() {
        // given
        final VendorV2 vendorGvl = VendorV2.builder().purposes(EnumSet.of(PURPOSE)).flexiblePurposes(EnumSet.noneOf(Purpose.clreplaced)).build();
        final VendorPermission vendorPermission = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl = VendorPermissionWithGvl.of(vendorPermission, vendorGvl);
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = singletonList(vendorPermissionWitGvl);
        given(purposesConsent.contains(anyInt())).willReturn(true);
        given(allowedVendors.contains(anyInt())).willReturn(true);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPermissionWithGvls, emptyList(), true);
        // then
        replacedertThat(result).usingFieldByFieldElementComparator().containsOnly(vendorPermission);
        verify(purposesConsent).contains(PURPOSE.code());
        verify(allowedVendors).contains(1);
    }

    @Test
    public void shouldEmptyWhenInGvlPurposeAndPurposeConsentAllowedAndVendorLIAllowedAndEnforced() {
        // given
        final VendorV2 vendorGvl = VendorV2.builder().purposes(EnumSet.of(PURPOSE)).flexiblePurposes(EnumSet.noneOf(Purpose.clreplaced)).build();
        final VendorPermission vendorPermission = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl = VendorPermissionWithGvl.of(vendorPermission, vendorGvl);
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = singletonList(vendorPermissionWitGvl);
        given(purposesConsent.contains(anyInt())).willReturn(true);
        given(allowedVendorsLI.contains(anyInt())).willReturn(true);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPermissionWithGvls, emptyList(), true);
        // then
        replacedertThat(result).isEmpty();
        verify(purposesConsent).contains(PURPOSE.code());
        verifyZeroInteractions(purposesLI);
    }

    @Test
    public void shouldAllowWhenInGvlPurposeLIAndPurposeLI() {
        // given
        final VendorV2 vendorGvl = VendorV2.builder().legIntPurposes(EnumSet.of(PURPOSE)).flexiblePurposes(EnumSet.noneOf(Purpose.clreplaced)).build();
        final VendorPermission vendorPermission = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl = VendorPermissionWithGvl.of(vendorPermission, vendorGvl);
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = singletonList(vendorPermissionWitGvl);
        given(purposesLI.contains(anyInt())).willReturn(true);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPermissionWithGvls, emptyList(), false);
        // then
        replacedertThat(result).usingFieldByFieldElementComparator().containsOnly(vendorPermission);
        verify(purposesLI).contains(PURPOSE.code());
    }

    @Test
    public void shouldAllowWhenInGvlPurposeLIAndPurposeLIAndVendorLIAllowedAndEnforced() {
        // given
        final VendorV2 vendorGvl = VendorV2.builder().legIntPurposes(EnumSet.of(PURPOSE)).flexiblePurposes(EnumSet.noneOf(Purpose.clreplaced)).build();
        final VendorPermission vendorPermission = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl = VendorPermissionWithGvl.of(vendorPermission, vendorGvl);
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = singletonList(vendorPermissionWitGvl);
        given(purposesLI.contains(anyInt())).willReturn(true);
        given(allowedVendorsLI.contains(anyInt())).willReturn(true);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPermissionWithGvls, emptyList(), true);
        // then
        replacedertThat(result).usingFieldByFieldElementComparator().containsOnly(vendorPermission);
        verify(purposesLI).contains(PURPOSE.code());
        verify(allowedVendorsLI).contains(1);
    }

    @Test
    public void shouldEmptyWhenInGvlPurposeLIAndPurposeConsentAllowedAndVendorConsentAllowedAndEnforced() {
        // given
        final VendorV2 vendorGvl = VendorV2.builder().legIntPurposes(EnumSet.of(PURPOSE)).flexiblePurposes(EnumSet.noneOf(Purpose.clreplaced)).build();
        final VendorPermission vendorPermission = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl = VendorPermissionWithGvl.of(vendorPermission, vendorGvl);
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = singletonList(vendorPermissionWitGvl);
        given(purposesLI.contains(anyInt())).willReturn(true);
        given(purposesConsent.contains(anyInt())).willReturn(true);
        given(allowedVendors.contains(anyInt())).willReturn(true);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPermissionWithGvls, emptyList(), true);
        // then
        replacedertThat(result).isEmpty();
        verify(purposesLI).contains(PURPOSE.code());
        verifyZeroInteractions(allowedVendors);
    }

    // Flexible GVL Purpose part
    // Restriction type is REQUIRE_CONSENT
    @Test
    public void shouldAllowWhenInGvlPurposeAndPurposeConsentAllowedAndFlexibleAndRequireConsent() {
        // given
        final VendorV2 vendorGvl = VendorV2.builder().purposes(EnumSet.of(PURPOSE)).flexiblePurposes(EnumSet.of(PURPOSE)).build();
        final VendorPermission vendorPermission = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl = VendorPermissionWithGvl.of(vendorPermission, vendorGvl);
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = singletonList(vendorPermissionWitGvl);
        given(publisherRestriction.getRestrictionType()).willReturn(RestrictionType.REQUIRE_CONSENT);
        given(purposesConsent.contains(anyInt())).willReturn(true);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPermissionWithGvls, emptyList(), false);
        // then
        replacedertThat(result).usingFieldByFieldElementComparator().containsOnly(vendorPermission);
        verify(purposesConsent).contains(PURPOSE.code());
    }

    @Test
    public void shouldAllowWhenInGvlPurposeAndPurposeConsentAndVendorConsentAndEnforcedAndFlexibleAndRequireConsent() {
        // given
        final VendorV2 vendorGvl = VendorV2.builder().purposes(EnumSet.of(PURPOSE)).flexiblePurposes(EnumSet.of(PURPOSE)).build();
        final VendorPermission vendorPermission = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl = VendorPermissionWithGvl.of(vendorPermission, vendorGvl);
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = singletonList(vendorPermissionWitGvl);
        given(publisherRestriction.getRestrictionType()).willReturn(RestrictionType.REQUIRE_CONSENT);
        given(purposesConsent.contains(anyInt())).willReturn(true);
        given(allowedVendors.contains(anyInt())).willReturn(true);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPermissionWithGvls, emptyList(), true);
        // then
        replacedertThat(result).usingFieldByFieldElementComparator().containsOnly(vendorPermission);
        verify(purposesConsent).contains(PURPOSE.code());
        verify(allowedVendors).contains(1);
    }

    @Test
    public void shouldEmptyWhenInGvlPurposeAndPurposeLIAllowedAndFlexibleAndRequireConsent() {
        // given
        final VendorV2 vendorGvl = VendorV2.builder().purposes(EnumSet.of(PURPOSE)).flexiblePurposes(EnumSet.of(PURPOSE)).build();
        final VendorPermission vendorPermission = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl = VendorPermissionWithGvl.of(vendorPermission, vendorGvl);
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = singletonList(vendorPermissionWitGvl);
        given(publisherRestriction.getRestrictionType()).willReturn(RestrictionType.REQUIRE_CONSENT);
        given(vendorIds.contains(anyInt())).willReturn(true);
        given(purposesLI.contains(anyInt())).willReturn(true);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPermissionWithGvls, emptyList(), false);
        // then
        replacedertThat(result).isEmpty();
        verifyZeroInteractions(purposesLI);
    }

    @Test
    public void shouldEmptyWhenInGvlPurposeAndPurposeLIAndVendorLIAllowedAndEnforcedAndFlexibleAndRequireConsent() {
        // given
        final VendorV2 vendorGvl = VendorV2.builder().purposes(EnumSet.of(PURPOSE)).flexiblePurposes(EnumSet.of(PURPOSE)).build();
        final VendorPermission vendorPermission = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl = VendorPermissionWithGvl.of(vendorPermission, vendorGvl);
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = singletonList(vendorPermissionWitGvl);
        given(publisherRestriction.getRestrictionType()).willReturn(RestrictionType.REQUIRE_CONSENT);
        given(vendorIds.contains(anyInt())).willReturn(true);
        given(purposesLI.contains(anyInt())).willReturn(true);
        given(allowedVendorsLI.contains(anyInt())).willReturn(true);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPermissionWithGvls, emptyList(), true);
        // then
        replacedertThat(result).isEmpty();
        verifyZeroInteractions(purposesLI);
        verifyZeroInteractions(allowedVendorsLI);
    }

    @Test
    public void shouldEmptyWhenInGvlPurposeAndPurposeConsentAndVendorLIAndEnforcedAndFlexibleAndRequireConsent() {
        // given
        final VendorV2 vendorGvl = VendorV2.builder().purposes(EnumSet.of(PURPOSE)).flexiblePurposes(EnumSet.of(PURPOSE)).build();
        final VendorPermission vendorPermission = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl = VendorPermissionWithGvl.of(vendorPermission, vendorGvl);
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = singletonList(vendorPermissionWitGvl);
        given(publisherRestriction.getRestrictionType()).willReturn(RestrictionType.REQUIRE_CONSENT);
        given(purposesConsent.contains(anyInt())).willReturn(true);
        given(allowedVendorsLI.contains(anyInt())).willReturn(true);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPermissionWithGvls, emptyList(), true);
        // then
        replacedertThat(result).isEmpty();
        verify(purposesConsent).contains(PURPOSE.code());
    }

    @Test
    public void shouldEmptyWhenInGvlPurposeAndPurposeLIAndVendorConsentAndEnforcedAndFlexibleAndRequireConsent() {
        // given
        final VendorV2 vendorGvl = VendorV2.builder().purposes(EnumSet.of(PURPOSE)).flexiblePurposes(EnumSet.of(PURPOSE)).build();
        final VendorPermission vendorPermission = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl = VendorPermissionWithGvl.of(vendorPermission, vendorGvl);
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = singletonList(vendorPermissionWitGvl);
        given(publisherRestriction.getRestrictionType()).willReturn(RestrictionType.REQUIRE_CONSENT);
        given(purposesLI.contains(anyInt())).willReturn(true);
        given(allowedVendors.contains(anyInt())).willReturn(true);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPermissionWithGvls, emptyList(), true);
        // then
        replacedertThat(result).isEmpty();
    }

    // Restriction tipe is REQUIRE_LEGITIMATE_INTEREST
    @Test
    public void shouldEmptyWhenInGvlPurposeAndPurposeConsentAllowedAndFlexibleAndRequireLI() {
        // given
        final VendorV2 vendorGvl = VendorV2.builder().purposes(EnumSet.of(PURPOSE)).flexiblePurposes(EnumSet.of(PURPOSE)).build();
        final VendorPermission vendorPermission = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl = VendorPermissionWithGvl.of(vendorPermission, vendorGvl);
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = singletonList(vendorPermissionWitGvl);
        given(publisherRestriction.getRestrictionType()).willReturn(RestrictionType.REQUIRE_LEGITIMATE_INTEREST);
        given(vendorIds.contains(anyInt())).willReturn(true);
        given(purposesConsent.contains(anyInt())).willReturn(true);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPermissionWithGvls, emptyList(), false);
        // then
        replacedertThat(result).isEmpty();
        verifyZeroInteractions(purposesConsent);
    }

    @Test
    public void shouldEmptyWhenInGvlPurposeAndPurposeConsentAndVendorConsentAndEnforcedAndFlexibleAndRequireLI() {
        // given
        final VendorV2 vendorGvl = VendorV2.builder().purposes(EnumSet.of(PURPOSE)).flexiblePurposes(EnumSet.of(PURPOSE)).build();
        final VendorPermission vendorPermission = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl = VendorPermissionWithGvl.of(vendorPermission, vendorGvl);
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = singletonList(vendorPermissionWitGvl);
        given(publisherRestriction.getRestrictionType()).willReturn(RestrictionType.REQUIRE_LEGITIMATE_INTEREST);
        given(vendorIds.contains(anyInt())).willReturn(true);
        given(purposesConsent.contains(anyInt())).willReturn(true);
        given(allowedVendors.contains(anyInt())).willReturn(true);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPermissionWithGvls, emptyList(), true);
        // then
        replacedertThat(result).isEmpty();
        verifyZeroInteractions(purposesConsent);
        verifyZeroInteractions(allowedVendors);
    }

    @Test
    public void shouldAllowWhenInGvlPurposeAndPurposeLIAllowedAndFlexibleAndRequireLI() {
        // given
        final VendorV2 vendorGvl = VendorV2.builder().purposes(EnumSet.of(PURPOSE)).flexiblePurposes(EnumSet.of(PURPOSE)).build();
        final VendorPermission vendorPermission = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl = VendorPermissionWithGvl.of(vendorPermission, vendorGvl);
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = singletonList(vendorPermissionWitGvl);
        given(publisherRestriction.getRestrictionType()).willReturn(RestrictionType.REQUIRE_LEGITIMATE_INTEREST);
        given(purposesLI.contains(anyInt())).willReturn(true);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPermissionWithGvls, emptyList(), false);
        // then
        replacedertThat(result).usingFieldByFieldElementComparator().containsOnly(vendorPermission);
        verify(purposesLI).contains(PURPOSE.code());
    }

    @Test
    public void shouldAllowWhenInGvlPurposeAndPurposeLIAndVendorLIAllowedAndEnforcedAndFlexibleAndRequireLI() {
        // given
        final VendorV2 vendorGvl = VendorV2.builder().purposes(EnumSet.of(PURPOSE)).flexiblePurposes(EnumSet.of(PURPOSE)).build();
        final VendorPermission vendorPermission = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl = VendorPermissionWithGvl.of(vendorPermission, vendorGvl);
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = singletonList(vendorPermissionWitGvl);
        given(publisherRestriction.getRestrictionType()).willReturn(RestrictionType.REQUIRE_LEGITIMATE_INTEREST);
        given(purposesLI.contains(anyInt())).willReturn(true);
        given(allowedVendorsLI.contains(anyInt())).willReturn(true);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPermissionWithGvls, emptyList(), true);
        // then
        replacedertThat(result).usingFieldByFieldElementComparator().containsOnly(vendorPermission);
        verify(purposesLI).contains(PURPOSE.code());
        verify(allowedVendorsLI).contains(1);
    }

    @Test
    public void shouldEmptyWhenInGvlPurposeAndPurposeConsentAndVendorLIAllowedAndEnforcedAndFlexibleAndRequireLI() {
        // given
        final VendorV2 vendorGvl = VendorV2.builder().purposes(EnumSet.of(PURPOSE)).flexiblePurposes(EnumSet.of(PURPOSE)).build();
        final VendorPermission vendorPermission = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl = VendorPermissionWithGvl.of(vendorPermission, vendorGvl);
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = singletonList(vendorPermissionWitGvl);
        given(publisherRestriction.getRestrictionType()).willReturn(RestrictionType.REQUIRE_LEGITIMATE_INTEREST);
        given(vendorIds.contains(anyInt())).willReturn(true);
        given(purposesConsent.contains(anyInt())).willReturn(true);
        given(allowedVendorsLI.contains(anyInt())).willReturn(true);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPermissionWithGvls, emptyList(), true);
        // then
        replacedertThat(result).isEmpty();
        verify(allowedVendorsLI).contains(1);
        verifyZeroInteractions(purposesConsent);
    }

    @Test
    public void shouldEmptyWhenInGvlPurposeAndPurposeLIAndVendorConsentAllowedAndEnforcedAndFlexibleAndRequireLI() {
        // given
        final VendorV2 vendorGvl = VendorV2.builder().purposes(EnumSet.of(PURPOSE)).flexiblePurposes(EnumSet.of(PURPOSE)).build();
        final VendorPermission vendorPermission = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl = VendorPermissionWithGvl.of(vendorPermission, vendorGvl);
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = singletonList(vendorPermissionWitGvl);
        given(publisherRestriction.getRestrictionType()).willReturn(RestrictionType.REQUIRE_LEGITIMATE_INTEREST);
        given(vendorIds.contains(anyInt())).willReturn(true);
        given(purposesLI.contains(anyInt())).willReturn(true);
        given(allowedVendors.contains(anyInt())).willReturn(true);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPermissionWithGvls, emptyList(), true);
        // then
        replacedertThat(result).isEmpty();
        verify(purposesLI).contains(PURPOSE.code());
        verifyZeroInteractions(allowedVendors);
    }

    // Flexible GVL Purpose Legitimate interest part
    // Restriction type is REQUIRE_CONSENT
    @Test
    public void shouldAllowWhenInGvlPurposeLIAndPurposeConsentAllowedAndFlexibleAndRequireConsent() {
        // given
        final VendorV2 vendorGvl = VendorV2.builder().legIntPurposes(EnumSet.of(PURPOSE)).flexiblePurposes(EnumSet.of(PURPOSE)).build();
        final VendorPermission vendorPermission = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl = VendorPermissionWithGvl.of(vendorPermission, vendorGvl);
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = singletonList(vendorPermissionWitGvl);
        given(publisherRestriction.getRestrictionType()).willReturn(RestrictionType.REQUIRE_CONSENT);
        given(purposesConsent.contains(anyInt())).willReturn(true);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPermissionWithGvls, emptyList(), false);
        // then
        replacedertThat(result).usingFieldByFieldElementComparator().containsOnly(vendorPermission);
        verify(purposesConsent).contains(PURPOSE.code());
    }

    @Test
    public void shouldAllowWhenInGvlPurposeLIAndPurposeAndVendorConsentAndEnforcedAndFlexibleAndRequireConsent() {
        // given
        final VendorV2 vendorGvl = VendorV2.builder().legIntPurposes(EnumSet.of(PURPOSE)).flexiblePurposes(EnumSet.of(PURPOSE)).build();
        final VendorPermission vendorPermission = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl = VendorPermissionWithGvl.of(vendorPermission, vendorGvl);
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = singletonList(vendorPermissionWitGvl);
        given(publisherRestriction.getRestrictionType()).willReturn(RestrictionType.REQUIRE_CONSENT);
        given(purposesConsent.contains(anyInt())).willReturn(true);
        given(allowedVendors.contains(anyInt())).willReturn(true);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPermissionWithGvls, emptyList(), true);
        // then
        replacedertThat(result).usingFieldByFieldElementComparator().containsOnly(vendorPermission);
        verify(purposesConsent).contains(PURPOSE.code());
        verify(allowedVendors).contains(1);
    }

    @Test
    public void shouldEmptyWhenInGvlPurposeLIAndPurposeLIAllowedAndFlexibleAndRequireConsent() {
        // given
        final VendorV2 vendorGvl = VendorV2.builder().legIntPurposes(EnumSet.of(PURPOSE)).flexiblePurposes(EnumSet.of(PURPOSE)).build();
        final VendorPermission vendorPermission = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl = VendorPermissionWithGvl.of(vendorPermission, vendorGvl);
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = singletonList(vendorPermissionWitGvl);
        given(publisherRestriction.getRestrictionType()).willReturn(RestrictionType.REQUIRE_CONSENT);
        given(vendorIds.contains(anyInt())).willReturn(true);
        given(purposesLI.contains(anyInt())).willReturn(true);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPermissionWithGvls, emptyList(), false);
        // then
        replacedertThat(result).isEmpty();
        verifyZeroInteractions(purposesLI);
    }

    @Test
    public void shouldEmptyWhenInGvlPurposeLIAndPurposeLIAndVendorLIAllowedAndEnforcedAndFlexibleAndRequireConsent() {
        // given
        final VendorV2 vendorGvl = VendorV2.builder().legIntPurposes(EnumSet.of(PURPOSE)).flexiblePurposes(EnumSet.of(PURPOSE)).build();
        final VendorPermission vendorPermission = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl = VendorPermissionWithGvl.of(vendorPermission, vendorGvl);
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = singletonList(vendorPermissionWitGvl);
        given(publisherRestriction.getRestrictionType()).willReturn(RestrictionType.REQUIRE_CONSENT);
        given(vendorIds.contains(anyInt())).willReturn(true);
        given(purposesLI.contains(anyInt())).willReturn(true);
        given(allowedVendorsLI.contains(anyInt())).willReturn(true);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPermissionWithGvls, emptyList(), true);
        // then
        replacedertThat(result).isEmpty();
        verifyZeroInteractions(purposesLI);
        verifyZeroInteractions(allowedVendorsLI);
    }

    @Test
    public void shouldEmptyWhenInGvlPurposeLIAndPurposeConsentAndVendorLIAndEnforcedAndFlexibleAndRequireConsent() {
        // given
        final VendorV2 vendorGvl = VendorV2.builder().legIntPurposes(EnumSet.of(PURPOSE)).flexiblePurposes(EnumSet.of(PURPOSE)).build();
        final VendorPermission vendorPermission = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl = VendorPermissionWithGvl.of(vendorPermission, vendorGvl);
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = singletonList(vendorPermissionWitGvl);
        given(publisherRestriction.getRestrictionType()).willReturn(RestrictionType.REQUIRE_CONSENT);
        given(vendorIds.contains(anyInt())).willReturn(true);
        given(purposesConsent.contains(anyInt())).willReturn(true);
        given(allowedVendorsLI.contains(anyInt())).willReturn(true);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPermissionWithGvls, emptyList(), true);
        // then
        replacedertThat(result).isEmpty();
        verify(purposesConsent).contains(PURPOSE.code());
        verifyZeroInteractions(allowedVendorsLI);
    }

    @Test
    public void shouldEmptyWhenInGvlPurposeLIAndPurposeLIAndVendorConsentAndEnforcedAndFlexibleAndRequireConsent() {
        // given
        final VendorV2 vendorGvl = VendorV2.builder().legIntPurposes(EnumSet.of(PURPOSE)).flexiblePurposes(EnumSet.of(PURPOSE)).build();
        final VendorPermission vendorPermission = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl = VendorPermissionWithGvl.of(vendorPermission, vendorGvl);
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = singletonList(vendorPermissionWitGvl);
        given(publisherRestriction.getRestrictionType()).willReturn(RestrictionType.REQUIRE_CONSENT);
        given(vendorIds.contains(anyInt())).willReturn(true);
        given(purposesLI.contains(anyInt())).willReturn(true);
        given(allowedVendors.contains(anyInt())).willReturn(true);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPermissionWithGvls, emptyList(), true);
        // then
        replacedertThat(result).isEmpty();
        verify(allowedVendors).contains(PURPOSE.code());
        verifyZeroInteractions(purposesLI);
    }

    // Restriction type is REQUIRE_LEGITIMATE_INTEREST
    @Test
    public void shouldEmptyWhenInGvlPurposeLIAndPurposeConsentAllowedAndFlexibleAndRequireLI() {
        // given
        final VendorV2 vendorGvl = VendorV2.builder().legIntPurposes(EnumSet.of(PURPOSE)).flexiblePurposes(EnumSet.of(PURPOSE)).build();
        final VendorPermission vendorPermission = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl = VendorPermissionWithGvl.of(vendorPermission, vendorGvl);
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = singletonList(vendorPermissionWitGvl);
        given(publisherRestriction.getRestrictionType()).willReturn(RestrictionType.REQUIRE_LEGITIMATE_INTEREST);
        given(vendorIds.contains(anyInt())).willReturn(true);
        given(purposesConsent.contains(anyInt())).willReturn(true);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPermissionWithGvls, emptyList(), false);
        // then
        replacedertThat(result).isEmpty();
        verifyZeroInteractions(purposesConsent);
    }

    @Test
    public void shouldEmptyWhenInGvlPurposeLIAndPurposeConsentAndVendorConsentAndEnforcedAndFlexibleAndRequireLI() {
        // given
        final VendorV2 vendorGvl = VendorV2.builder().legIntPurposes(EnumSet.of(PURPOSE)).flexiblePurposes(EnumSet.of(PURPOSE)).build();
        final VendorPermission vendorPermission = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl = VendorPermissionWithGvl.of(vendorPermission, vendorGvl);
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = singletonList(vendorPermissionWitGvl);
        given(publisherRestriction.getRestrictionType()).willReturn(RestrictionType.REQUIRE_LEGITIMATE_INTEREST);
        given(vendorIds.contains(anyInt())).willReturn(true);
        given(purposesConsent.contains(anyInt())).willReturn(true);
        given(allowedVendors.contains(anyInt())).willReturn(true);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPermissionWithGvls, emptyList(), true);
        // then
        replacedertThat(result).isEmpty();
        verifyZeroInteractions(purposesConsent);
        verifyZeroInteractions(allowedVendors);
    }

    @Test
    public void shouldAllowWhenInGvlPurposeLIAndPurposeLIAllowedAndFlexibleAndRequireLI() {
        // given
        final VendorV2 vendorGvl = VendorV2.builder().legIntPurposes(EnumSet.of(PURPOSE)).flexiblePurposes(EnumSet.of(PURPOSE)).build();
        final VendorPermission vendorPermission = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl = VendorPermissionWithGvl.of(vendorPermission, vendorGvl);
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = singletonList(vendorPermissionWitGvl);
        given(publisherRestriction.getRestrictionType()).willReturn(RestrictionType.REQUIRE_LEGITIMATE_INTEREST);
        given(purposesLI.contains(anyInt())).willReturn(true);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPermissionWithGvls, emptyList(), false);
        // then
        replacedertThat(result).usingFieldByFieldElementComparator().containsOnly(vendorPermission);
        verify(purposesLI).contains(PURPOSE.code());
    }

    @Test
    public void shouldAllowWhenInGvlPurposeLIAndPurposeLIAndVendorLIAllowedAndEnforcedAndFlexibleAndRequireLI() {
        // given
        final VendorV2 vendorGvl = VendorV2.builder().legIntPurposes(EnumSet.of(PURPOSE)).flexiblePurposes(EnumSet.of(PURPOSE)).build();
        final VendorPermission vendorPermission = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl = VendorPermissionWithGvl.of(vendorPermission, vendorGvl);
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = singletonList(vendorPermissionWitGvl);
        given(publisherRestriction.getRestrictionType()).willReturn(RestrictionType.REQUIRE_LEGITIMATE_INTEREST);
        given(purposesLI.contains(anyInt())).willReturn(true);
        given(allowedVendorsLI.contains(anyInt())).willReturn(true);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPermissionWithGvls, emptyList(), true);
        // then
        replacedertThat(result).usingFieldByFieldElementComparator().containsOnly(vendorPermission);
        verify(purposesLI).contains(PURPOSE.code());
        verify(allowedVendorsLI).contains(1);
    }

    @Test
    public void shouldEmptyWhenInGvlPurposeLIAndPurposeConsentAndVendorLIAllowedAndEnforcedAndFlexibleAndRequireLI() {
        // given
        final VendorV2 vendorGvl = VendorV2.builder().legIntPurposes(EnumSet.of(PURPOSE)).flexiblePurposes(EnumSet.of(PURPOSE)).build();
        final VendorPermission vendorPermission = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl = VendorPermissionWithGvl.of(vendorPermission, vendorGvl);
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = singletonList(vendorPermissionWitGvl);
        given(publisherRestriction.getRestrictionType()).willReturn(RestrictionType.REQUIRE_LEGITIMATE_INTEREST);
        given(vendorIds.contains(anyInt())).willReturn(true);
        given(purposesConsent.contains(anyInt())).willReturn(true);
        given(allowedVendorsLI.contains(anyInt())).willReturn(true);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPermissionWithGvls, emptyList(), true);
        // then
        replacedertThat(result).isEmpty();
        verify(allowedVendorsLI).contains(1);
        verifyZeroInteractions(purposesConsent);
    }

    @Test
    public void shouldEmptyWhenInGvlPurposeLIAndPurposeLIAndVendorConsentAllowedAndEnforcedAndFlexibleAndRequireLI() {
        // given
        final VendorV2 vendorGvl = VendorV2.builder().legIntPurposes(EnumSet.of(PURPOSE)).flexiblePurposes(EnumSet.of(PURPOSE)).build();
        final VendorPermission vendorPermission = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl = VendorPermissionWithGvl.of(vendorPermission, vendorGvl);
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = singletonList(vendorPermissionWitGvl);
        given(publisherRestriction.getRestrictionType()).willReturn(RestrictionType.REQUIRE_LEGITIMATE_INTEREST);
        given(vendorIds.contains(anyInt())).willReturn(true);
        given(purposesLI.contains(anyInt())).willReturn(true);
        given(allowedVendors.contains(anyInt())).willReturn(true);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPermissionWithGvls, emptyList(), true);
        // then
        replacedertThat(result).isEmpty();
        verify(purposesLI).contains(1);
        verifyZeroInteractions(allowedVendors);
    }

    @Test
    public void shouldReturnExcludedVendors() {
        // given
        final VendorPermission vendorPermission1 = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, singleton(vendorPermissionWitGvl1), singleton(vendorPermissionWitGvl2), true);
        // then
        replacedertThat(result).usingFieldByFieldElementComparator().containsOnly(vendorPermission2);
    }
}

16 Source : BasicEnforcePurposeStrategyTest.java
with Apache License 2.0
from prebid

public clreplaced BasicEnforcePurposeStrategyTest {

    private static final Purpose PURPOSE = Purpose.ONE;

    @Rule
    public final MockitoRule mockitoRule = MockitoJUnit.rule();

    private BasicEnforcePurposeStrategy target;

    @Mock
    private TCString tcString;

    @Mock
    private Inreplacederable allowedVendors;

    @Mock
    private Inreplacederable allowedVendorsLI;

    @Mock
    private Inreplacederable purposesConsent;

    @Mock
    private Inreplacederable purposesLI;

    @Before
    public void setUp() {
        given(tcString.getVendorConsent()).willReturn(allowedVendors);
        given(tcString.getVendorLegitimateInterest()).willReturn(allowedVendorsLI);
        given(tcString.getPurposesConsent()).willReturn(purposesConsent);
        given(tcString.getPurposesLITransparency()).willReturn(purposesLI);
        given(allowedVendors.contains(anyInt())).willReturn(false);
        given(allowedVendorsLI.contains(anyInt())).willReturn(false);
        given(purposesConsent.contains(anyInt())).willReturn(false);
        given(purposesLI.contains(anyInt())).willReturn(false);
        target = new BasicEnforcePurposeStrategy();
    }

    @Test
    public void allowedByTypeStrategyShouldReturnEmptyListWhenVendorIsNotAllowedAndVendorIsNotEnforced() {
        // given
        final VendorPermission vendorPermission = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl = VendorPermissionWithGvl.of(vendorPermission, VendorV2.empty(1));
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = singletonList(vendorPermissionWitGvl);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPermissionWithGvls, emptyList(), false);
        // then
        replacedertThat(result).isEmpty();
    }

    @Test
    public void allowedByTypeStrategyShouldReturnEmptyListWhenVendorIsNotAllowedAndVendorEnforced() {
        // given
        final VendorPermission vendorPermission = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl = VendorPermissionWithGvl.of(vendorPermission, VendorV2.empty(1));
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = singletonList(vendorPermissionWitGvl);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPermissionWithGvls, emptyList(), true);
        // then
        replacedertThat(result).isEmpty();
    }

    @Test
    public void allowedByTypeStrategyShouldReturnExpectedValueWhenVendorIsAllowedAndVendorEnforced() {
        // given
        final VendorPermission vendorPermission = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl = VendorPermissionWithGvl.of(vendorPermission, VendorV2.empty(1));
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = singletonList(vendorPermissionWitGvl);
        given(allowedVendors.contains(anyInt())).willReturn(true);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPermissionWithGvls, emptyList(), true);
        // then
        replacedertThat(result).isEmpty();
    }

    @Test
    public void allowedByTypeStrategyShouldReturnExpectedValueWhenVendorIsAllowedAndVendorIsNotEnforced() {
        // given
        final VendorPermission vendorPermission = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl = VendorPermissionWithGvl.of(vendorPermission, VendorV2.empty(1));
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = singletonList(vendorPermissionWitGvl);
        given(allowedVendors.contains(anyInt())).willReturn(true);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPermissionWithGvls, emptyList(), false);
        // then
        replacedertThat(result).isEmpty();
    }

    @Test
    public void allowedByTypeStrategyShouldReturnExpectedValueWhenVendorLIIsAllowedAndVendorEnforced() {
        // given
        final VendorPermission vendorPermission = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl = VendorPermissionWithGvl.of(vendorPermission, VendorV2.empty(1));
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = singletonList(vendorPermissionWitGvl);
        given(allowedVendorsLI.contains(anyInt())).willReturn(true);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPermissionWithGvls, emptyList(), true);
        // then
        replacedertThat(result).isEmpty();
    }

    @Test
    public void allowedByTypeStrategyShouldReturnExpectedValueWhenVendorLIIsAllowedAndVendorIsNotEnforced() {
        // given
        final VendorPermission vendorPermission = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl = VendorPermissionWithGvl.of(vendorPermission, VendorV2.empty(1));
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = singletonList(vendorPermissionWitGvl);
        given(allowedVendorsLI.contains(anyInt())).willReturn(true);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPermissionWithGvls, emptyList(), false);
        // then
        replacedertThat(result).isEmpty();
    }

    @Test
    public void allowedByTypeStrategyShouldReturnExpectedValueWhenPurposeLIAndPurposeIsAllowedAndVendorIsNotEnforced() {
        // given
        final VendorPermission vendorPermission = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl = VendorPermissionWithGvl.of(vendorPermission, VendorV2.empty(1));
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = singletonList(vendorPermissionWitGvl);
        given(purposesConsent.contains(anyInt())).willReturn(true);
        given(purposesLI.contains(anyInt())).willReturn(true);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPermissionWithGvls, emptyList(), false);
        // then
        replacedertThat(result).usingFieldByFieldElementComparator().containsOnly(vendorPermission);
    }

    @Test
    public void allowedByTypeStrategyShouldReturnExpectedValueWhenPurposeLIAndPurposeIsAllowedAndVendorEnforced() {
        // given
        final VendorPermission vendorPermission = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl = VendorPermissionWithGvl.of(vendorPermission, VendorV2.empty(1));
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = singletonList(vendorPermissionWitGvl);
        given(purposesConsent.contains(anyInt())).willReturn(true);
        given(purposesLI.contains(anyInt())).willReturn(true);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPermissionWithGvls, emptyList(), true);
        // then
        replacedertThat(result).isEmpty();
    }

    @Test
    public void allowedByTypeStrategyShouldReturnExpectedValueWhenPurposeLIAndVendorIsAllowedAndVendorIsNotEnforced() {
        // given
        final VendorPermission vendorPermission1 = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2);
        given(allowedVendors.contains(anyInt())).willReturn(true);
        given(purposesLI.contains(PURPOSE.code())).willReturn(true);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPermissionWithGvls, emptyList(), false);
        // then
        replacedertThat(result).isEmpty();
    }

    @Test
    public void allowedByTypeStrategyShouldReturnExpectedValueWhenPurposeAndVendorLIIsAllowedAndVendorIsNotEnforced() {
        // given
        final VendorPermission vendorPermission1 = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final List<VendorPermissionWithGvl> vendorPermissionWithGvls = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2);
        given(allowedVendorsLI.contains(anyInt())).willReturn(true);
        given(purposesConsent.contains(PURPOSE.code())).willReturn(true);
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, vendorPermissionWithGvls, emptyList(), false);
        // then
        replacedertThat(result).usingFieldByFieldElementComparator().containsOnly(vendorPermission1, vendorPermission2);
    }

    @Test
    public void allowedByTypeStrategyShouldReturnExcludedVendors() {
        // given
        final VendorPermission vendorPermission1 = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        // when
        final Collection<VendorPermission> result = target.allowedByTypeStrategy(PURPOSE, tcString, singleton(vendorPermissionWitGvl1), singleton(vendorPermissionWitGvl2), true);
        // then
        replacedertThat(result).usingFieldByFieldElementComparator().containsOnly(vendorPermission2);
    }
}

16 Source : PurposeTwoStrategyTest.java
with Apache License 2.0
from prebid

public clreplaced PurposeTwoStrategyTest {

    private static final org.prebid.server.privacy.gdpr.vendorlist.proto.Purpose PURPOSE = org.prebid.server.privacy.gdpr.vendorlist.proto.Purpose.TWO;

    @Rule
    public final MockitoRule mockitoRule = MockitoJUnit.rule();

    @Mock
    private FullEnforcePurposeStrategy fullEnforcePurposeStrategy;

    @Mock
    private BasicEnforcePurposeStrategy basicEnforcePurposeStrategy;

    @Mock
    private NoEnforcePurposeStrategy noEnforcePurposeStrategy;

    private PurposeTwoStrategy target;

    @Mock
    private TCString tcString;

    @Before
    public void setUp() {
        target = new PurposeTwoStrategy(fullEnforcePurposeStrategy, basicEnforcePurposeStrategy, noEnforcePurposeStrategy);
    }

    @Test
    public void allowShouldReturnExpectedValue() {
        // given
        final PrivacyEnforcementAction privacyEnforcementAction = PrivacyEnforcementAction.restrictAll();
        // when
        target.allow(privacyEnforcementAction);
        // then
        replacedertThat(privacyEnforcementAction).isEqualToComparingFieldByField(allowPurpose());
    }

    @Test
    public void allowNaturallyShouldReturnExpectedValue() {
        // given
        final PrivacyEnforcementAction privacyEnforcementAction = PrivacyEnforcementAction.restrictAll();
        // when
        target.allowNaturally(privacyEnforcementAction);
        // then
        replacedertThat(privacyEnforcementAction).isEqualToComparingFieldByField(allowNatural());
    }

    @Test
    public void getPurposeIdShouldReturnExpectedValue() {
        // when and then
        replacedertThat(target.getPurpose()).isEqualTo(PURPOSE);
    }

    @Test
    public void processTypePurposeStrategyShouldPreplacedListWithEnforcementsAndExcludeBiddersToNoType() {
        // given
        final List<String> vendorExceptions = Arrays.asList("b1", "b3");
        final Purpose purpose = Purpose.of(EnforcePurpose.no, false, vendorExceptions);
        final VendorPermission vendorPermission1 = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        given(noEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(Arrays.asList(vendorPermission1, vendorPermission2));
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, false);
        // then
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, null, allowPurpose());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b1", allowPurpose());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, null, PrivacyEnforcementAction.restrictAll());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(noEnforcePurposeStrategy).allowedByTypeStrategy(PURPOSE, tcString, Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl3), singletonList(vendorPermissionWitGvl2), false);
    }

    @Test
    public void processTypePurposeStrategyShouldPreplacedListWithEnforcementsAndExcludeBiddersToBaseType() {
        // given
        final List<String> vendorExceptions = Arrays.asList("b1", "b3");
        final Purpose purpose = Purpose.of(EnforcePurpose.basic, false, vendorExceptions);
        final VendorPermission vendorPermission1 = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        given(basicEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(Arrays.asList(vendorPermission1, vendorPermission2));
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, false);
        // then
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, null, allowPurpose());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b1", allowPurpose());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, null, PrivacyEnforcementAction.restrictAll());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(basicEnforcePurposeStrategy).allowedByTypeStrategy(PURPOSE, tcString, Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl3), singletonList(vendorPermissionWitGvl2), false);
    }

    @Test
    public void processTypePurposeStrategyShouldPreplacedListWithEnforcementsAndExcludeBiddersToFullType() {
        // given
        final Purpose purpose = Purpose.of(EnforcePurpose.basic, null, Arrays.asList("b1", "b2", "b3", "b5", "b7"));
        final VendorPermission vendorPermission1 = VendorPermission.of(1, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b2", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, "b3", PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermission> vendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2, vendorPermission3);
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        given(basicEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(vendorPermissions);
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, false);
        // then
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, "b1", allowPurpose());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b2", allowPurpose());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, "b3", allowPurpose());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(basicEnforcePurposeStrategy).allowedByTypeStrategy(PURPOSE, tcString, emptyList(), vendorPermissionsWithGvl, true);
    }

    @Test
    public void processTypePurposeStrategyShouldPreplacedEmptyListWithFullEnforcementsWhenAllBiddersAreExcluded() {
        // given
        final Purpose purpose = Purpose.of(EnforcePurpose.full, null, Arrays.asList("b1", "b2", "b3", "b5", "b7"));
        final VendorPermission vendorPermission1 = VendorPermission.of(1, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b2", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, "b3", PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermission> vendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2, vendorPermission3);
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        given(fullEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(vendorPermissions);
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, false);
        // then
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, "b1", allowPurposeAndNaturally());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b2", allowPurposeAndNaturally());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, "b3", allowPurposeAndNaturally());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(fullEnforcePurposeStrategy, times(2)).allowedByTypeStrategy(PURPOSE, tcString, emptyList(), vendorPermissionsWithGvl, true);
    }

    @Test
    public void processTypePurposeStrategyShouldAllowPurposeAndNaturallyVendorExceptions() {
        // given
        final Purpose purpose = Purpose.of(EnforcePurpose.full, null, Arrays.asList("b1", "b2"));
        final VendorPermission vendorPermission1 = VendorPermission.of(1, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b2", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, "b3", PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermission> vendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2, vendorPermission3);
        final List<VendorPermission> excludedVendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2);
        given(fullEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(vendorPermissions).willReturn(excludedVendorPermissions);
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, false);
        // then
        final List<VendorPermissionWithGvl> excludedVendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2);
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, "b1", allowPurposeAndNaturally());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b2", allowPurposeAndNaturally());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, "b3", allowPurpose());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(fullEnforcePurposeStrategy, times(2)).allowedByTypeStrategy(PURPOSE, tcString, singletonList(vendorPermissionWitGvl3), excludedVendorPermissionsWithGvl, true);
    }

    @Test
    public void processTypePurposeStrategyShouldAllowPurposeAndNaturallyWhenVendorPermissionsReturnedForDowngraded() {
        // given
        final Purpose purpose = Purpose.of(EnforcePurpose.no, null, Arrays.asList("b1", "b2"));
        final VendorPermission vendorPermission1 = VendorPermission.of(1, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b2", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, "b3", PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermission> vendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2, vendorPermission3);
        final List<VendorPermission> excludedVendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2);
        given(noEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(vendorPermissions);
        given(basicEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(excludedVendorPermissions);
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, true);
        // then
        final List<VendorPermissionWithGvl> excludedVendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2);
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, "b1", allowPurposeAndNaturally());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b2", allowPurposeAndNaturally());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, "b3", allowPurpose());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(noEnforcePurposeStrategy).allowedByTypeStrategy(PURPOSE, tcString, singletonList(vendorPermissionWitGvl3), excludedVendorPermissionsWithGvl, true);
        verify(basicEnforcePurposeStrategy).allowedByTypeStrategy(PURPOSE, tcString, singletonList(vendorPermissionWitGvl3), excludedVendorPermissionsWithGvl, true);
    }

    private static PrivacyEnforcementAction allowPurposeAndNaturally() {
        return allowNatural(allowPurpose());
    }

    private static PrivacyEnforcementAction allowPurpose() {
        final PrivacyEnforcementAction privacyEnforcementAction = PrivacyEnforcementAction.restrictAll();
        privacyEnforcementAction.setBlockBidderRequest(false);
        return privacyEnforcementAction;
    }

    private static PrivacyEnforcementAction allowNatural() {
        return allowNatural(PrivacyEnforcementAction.restrictAll());
    }

    private static PrivacyEnforcementAction allowNatural(PrivacyEnforcementAction privacyEnforcementAction) {
        privacyEnforcementAction.setRemoveUserIds(false);
        privacyEnforcementAction.setMaskDeviceInfo(false);
        return privacyEnforcementAction;
    }
}

16 Source : PurposeThreeStrategyTest.java
with Apache License 2.0
from prebid

public clreplaced PurposeThreeStrategyTest {

    private static final org.prebid.server.privacy.gdpr.vendorlist.proto.Purpose PURPOSE = org.prebid.server.privacy.gdpr.vendorlist.proto.Purpose.THREE;

    @Rule
    public final MockitoRule mockitoRule = MockitoJUnit.rule();

    @Mock
    private FullEnforcePurposeStrategy fullEnforcePurposeStrategy;

    @Mock
    private BasicEnforcePurposeStrategy basicEnforcePurposeStrategy;

    @Mock
    private NoEnforcePurposeStrategy noEnforcePurposeStrategy;

    private PurposeThreeStrategy target;

    @Mock
    private TCString tcString;

    @Before
    public void setUp() {
        target = new PurposeThreeStrategy(fullEnforcePurposeStrategy, basicEnforcePurposeStrategy, noEnforcePurposeStrategy);
    }

    @Test
    public void allowShouldReturnExpectedValue() {
        // given
        final PrivacyEnforcementAction privacyEnforcementAction = PrivacyEnforcementAction.restrictAll();
        // when
        target.allow(privacyEnforcementAction);
        // then
        replacedertThat(privacyEnforcementAction).isEqualToComparingFieldByField(allowPurpose());
    }

    @Test
    public void allowNaturallyShouldReturnExpectedValue() {
        // given
        final PrivacyEnforcementAction privacyEnforcementAction = PrivacyEnforcementAction.restrictAll();
        // when
        target.allowNaturally(privacyEnforcementAction);
        // then
        replacedertThat(privacyEnforcementAction).isEqualToComparingFieldByField(allowNatural());
    }

    @Test
    public void getPurposeIdShouldReturnExpectedValue() {
        // when and then
        replacedertThat(target.getPurpose()).isEqualTo(PURPOSE);
    }

    @Test
    public void processTypePurposeStrategyShouldPreplacedListWithEnforcementsAndExcludeBiddersToNoType() {
        // given
        final List<String> vendorExceptions = Arrays.asList("b1", "b3");
        final Purpose purpose = Purpose.of(EnforcePurpose.no, false, vendorExceptions);
        final VendorPermission vendorPermission1 = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        given(noEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(Arrays.asList(vendorPermission1, vendorPermission2));
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, false);
        // then
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, null, allowPurpose());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b1", allowPurpose());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, null, PrivacyEnforcementAction.restrictAll());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(noEnforcePurposeStrategy).allowedByTypeStrategy(PURPOSE, tcString, Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl3), singletonList(vendorPermissionWitGvl2), false);
    }

    @Test
    public void processTypePurposeStrategyShouldPreplacedListWithEnforcementsAndExcludeBiddersToBaseType() {
        // given
        final List<String> vendorExceptions = Arrays.asList("b1", "b3");
        final Purpose purpose = Purpose.of(EnforcePurpose.basic, false, vendorExceptions);
        final VendorPermission vendorPermission1 = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        given(basicEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(Arrays.asList(vendorPermission1, vendorPermission2));
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, false);
        // then
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, null, allowPurpose());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b1", allowPurpose());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, null, PrivacyEnforcementAction.restrictAll());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(basicEnforcePurposeStrategy).allowedByTypeStrategy(PURPOSE, tcString, Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl3), singletonList(vendorPermissionWitGvl2), false);
    }

    @Test
    public void processTypePurposeStrategyShouldPreplacedListWithEnforcementsAndExcludeBiddersToFullType() {
        // given
        final Purpose purpose = Purpose.of(EnforcePurpose.basic, null, Arrays.asList("b1", "b2", "b3", "b5", "b7"));
        final VendorPermission vendorPermission1 = VendorPermission.of(1, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b2", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, "b3", PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermission> vendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2, vendorPermission3);
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        given(basicEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(vendorPermissions);
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, false);
        // then
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, "b1", allowPurpose());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b2", allowPurpose());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, "b3", allowPurpose());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(basicEnforcePurposeStrategy).allowedByTypeStrategy(PURPOSE, tcString, emptyList(), vendorPermissionsWithGvl, true);
    }

    @Test
    public void processTypePurposeStrategyShouldPreplacedEmptyListWithFullEnforcementsWhenAllBiddersAreExcluded() {
        // given
        final Purpose purpose = Purpose.of(EnforcePurpose.full, null, Arrays.asList("b1", "b2", "b3", "b5", "b7"));
        final VendorPermission vendorPermission1 = VendorPermission.of(1, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b2", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, "b3", PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermission> vendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2, vendorPermission3);
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        given(fullEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(vendorPermissions);
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, false);
        // then
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, "b1", allowPurposeAndNaturally());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b2", allowPurposeAndNaturally());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, "b3", allowPurposeAndNaturally());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(fullEnforcePurposeStrategy, times(2)).allowedByTypeStrategy(PURPOSE, tcString, emptyList(), vendorPermissionsWithGvl, true);
    }

    @Test
    public void processTypePurposeStrategyShouldAllowPurposeAndNaturallyVendorExceptions() {
        // given
        final Purpose purpose = Purpose.of(EnforcePurpose.full, null, Arrays.asList("b1", "b2"));
        final VendorPermission vendorPermission1 = VendorPermission.of(1, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b2", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, "b3", PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermission> vendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2, vendorPermission3);
        final List<VendorPermission> excludedVendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2);
        given(fullEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(vendorPermissions).willReturn(excludedVendorPermissions);
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, false);
        // then
        final List<VendorPermissionWithGvl> excludedVendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2);
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, "b1", allowPurposeAndNaturally());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b2", allowPurposeAndNaturally());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, "b3", allowPurpose());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(fullEnforcePurposeStrategy, times(2)).allowedByTypeStrategy(PURPOSE, tcString, singletonList(vendorPermissionWitGvl3), excludedVendorPermissionsWithGvl, true);
    }

    @Test
    public void processTypePurposeStrategyShouldAllowPurposeAndNaturallyWhenVendorPermissionsReturnedForDowngraded() {
        // given
        final Purpose purpose = Purpose.of(EnforcePurpose.no, null, Arrays.asList("b1", "b2"));
        final VendorPermission vendorPermission1 = VendorPermission.of(1, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b2", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, "b3", PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermission> vendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2, vendorPermission3);
        final List<VendorPermission> excludedVendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2);
        given(noEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(vendorPermissions);
        given(basicEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(excludedVendorPermissions);
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, true);
        // then
        final List<VendorPermissionWithGvl> excludedVendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2);
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, "b1", allowPurposeAndNaturally());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b2", allowPurposeAndNaturally());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, "b3", allowPurpose());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(noEnforcePurposeStrategy).allowedByTypeStrategy(PURPOSE, tcString, singletonList(vendorPermissionWitGvl3), excludedVendorPermissionsWithGvl, true);
        verify(basicEnforcePurposeStrategy).allowedByTypeStrategy(PURPOSE, tcString, singletonList(vendorPermissionWitGvl3), excludedVendorPermissionsWithGvl, true);
    }

    private static PrivacyEnforcementAction allowPurposeAndNaturally() {
        return allowNatural(allowPurpose());
    }

    private static PrivacyEnforcementAction allowPurpose() {
        return PrivacyEnforcementAction.restrictAll();
    }

    private static PrivacyEnforcementAction allowNatural() {
        return allowNatural(PrivacyEnforcementAction.restrictAll());
    }

    private static PrivacyEnforcementAction allowNatural(PrivacyEnforcementAction privacyEnforcementAction) {
        privacyEnforcementAction.setRemoveUserIds(false);
        privacyEnforcementAction.setMaskDeviceInfo(false);
        return privacyEnforcementAction;
    }
}

16 Source : PurposeTenStrategyTest.java
with Apache License 2.0
from prebid

public clreplaced PurposeTenStrategyTest {

    private static final org.prebid.server.privacy.gdpr.vendorlist.proto.Purpose PURPOSE = org.prebid.server.privacy.gdpr.vendorlist.proto.Purpose.TEN;

    @Rule
    public final MockitoRule mockitoRule = MockitoJUnit.rule();

    @Mock
    private FullEnforcePurposeStrategy fullEnforcePurposeStrategy;

    @Mock
    private BasicEnforcePurposeStrategy basicEnforcePurposeStrategy;

    @Mock
    private NoEnforcePurposeStrategy noEnforcePurposeStrategy;

    private PurposeTenStrategy target;

    @Mock
    private TCString tcString;

    @Before
    public void setUp() {
        target = new PurposeTenStrategy(fullEnforcePurposeStrategy, basicEnforcePurposeStrategy, noEnforcePurposeStrategy);
    }

    @Test
    public void allowShouldReturnExpectedValue() {
        // given
        final PrivacyEnforcementAction privacyEnforcementAction = PrivacyEnforcementAction.restrictAll();
        // when
        target.allow(privacyEnforcementAction);
        // then
        replacedertThat(privacyEnforcementAction).isEqualToComparingFieldByField(allowPurpose());
    }

    @Test
    public void allowNaturallyShouldReturnExpectedValue() {
        // given
        final PrivacyEnforcementAction privacyEnforcementAction = PrivacyEnforcementAction.restrictAll();
        // when
        target.allowNaturally(privacyEnforcementAction);
        // then
        replacedertThat(privacyEnforcementAction).isEqualToComparingFieldByField(allowNatural());
    }

    @Test
    public void getPurposeIdShouldReturnExpectedValue() {
        // when and then
        replacedertThat(target.getPurpose()).isEqualTo(PURPOSE);
    }

    @Test
    public void processTypePurposeStrategyShouldPreplacedListWithEnforcementsAndExcludeBiddersToNoType() {
        // given
        final List<String> vendorExceptions = Arrays.asList("b1", "b3");
        final Purpose purpose = Purpose.of(EnforcePurpose.no, false, vendorExceptions);
        final VendorPermission vendorPermission1 = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        given(noEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(Arrays.asList(vendorPermission1, vendorPermission2));
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, false);
        // then
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, null, allowPurpose());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b1", allowPurpose());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, null, PrivacyEnforcementAction.restrictAll());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(noEnforcePurposeStrategy).allowedByTypeStrategy(PURPOSE, tcString, Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl3), singletonList(vendorPermissionWitGvl2), false);
    }

    @Test
    public void processTypePurposeStrategyShouldPreplacedListWithEnforcementsAndExcludeBiddersToBaseType() {
        // given
        final List<String> vendorExceptions = Arrays.asList("b1", "b3");
        final Purpose purpose = Purpose.of(EnforcePurpose.basic, false, vendorExceptions);
        final VendorPermission vendorPermission1 = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        given(basicEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(Arrays.asList(vendorPermission1, vendorPermission2));
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, false);
        // then
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, null, allowPurpose());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b1", allowPurpose());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, null, PrivacyEnforcementAction.restrictAll());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(basicEnforcePurposeStrategy).allowedByTypeStrategy(PURPOSE, tcString, Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl3), singletonList(vendorPermissionWitGvl2), false);
    }

    @Test
    public void processTypePurposeStrategyShouldPreplacedListWithEnforcementsAndExcludeBiddersToFullType() {
        // given
        final Purpose purpose = Purpose.of(EnforcePurpose.basic, null, Arrays.asList("b1", "b2", "b3", "b5", "b7"));
        final VendorPermission vendorPermission1 = VendorPermission.of(1, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b2", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, "b3", PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermission> vendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2, vendorPermission3);
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        given(basicEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(vendorPermissions);
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, false);
        // then
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, "b1", allowPurpose());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b2", allowPurpose());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, "b3", allowPurpose());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(basicEnforcePurposeStrategy).allowedByTypeStrategy(PURPOSE, tcString, emptyList(), vendorPermissionsWithGvl, true);
    }

    @Test
    public void processTypePurposeStrategyShouldPreplacedEmptyListWithFullEnforcementsWhenAllBiddersAreExcluded() {
        // given
        final Purpose purpose = Purpose.of(EnforcePurpose.full, null, Arrays.asList("b1", "b2", "b3", "b5", "b7"));
        final VendorPermission vendorPermission1 = VendorPermission.of(1, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b2", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, "b3", PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermission> vendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2, vendorPermission3);
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        given(fullEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(vendorPermissions);
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, false);
        // then
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, "b1", allowPurposeAndNaturally());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b2", allowPurposeAndNaturally());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, "b3", allowPurposeAndNaturally());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(fullEnforcePurposeStrategy, times(2)).allowedByTypeStrategy(PURPOSE, tcString, emptyList(), vendorPermissionsWithGvl, true);
    }

    @Test
    public void processTypePurposeStrategyShouldAllowPurposeAndNaturallyVendorExceptions() {
        // given
        final Purpose purpose = Purpose.of(EnforcePurpose.full, null, Arrays.asList("b1", "b2"));
        final VendorPermission vendorPermission1 = VendorPermission.of(1, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b2", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, "b3", PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermission> vendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2, vendorPermission3);
        final List<VendorPermission> excludedVendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2);
        given(fullEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(vendorPermissions).willReturn(excludedVendorPermissions);
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, false);
        // then
        final List<VendorPermissionWithGvl> excludedVendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2);
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, "b1", allowPurposeAndNaturally());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b2", allowPurposeAndNaturally());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, "b3", allowPurpose());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(fullEnforcePurposeStrategy, times(2)).allowedByTypeStrategy(PURPOSE, tcString, singletonList(vendorPermissionWitGvl3), excludedVendorPermissionsWithGvl, true);
    }

    @Test
    public void processTypePurposeStrategyShouldAllowPurposeAndNaturallyWhenVendorPermissionsReturnedForDowngraded() {
        // given
        final Purpose purpose = Purpose.of(EnforcePurpose.no, null, Arrays.asList("b1", "b2"));
        final VendorPermission vendorPermission1 = VendorPermission.of(1, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b2", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, "b3", PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermission> vendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2, vendorPermission3);
        final List<VendorPermission> excludedVendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2);
        given(noEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(vendorPermissions);
        given(basicEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(excludedVendorPermissions);
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, true);
        // then
        final List<VendorPermissionWithGvl> excludedVendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2);
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, "b1", allowPurposeAndNaturally());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b2", allowPurposeAndNaturally());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, "b3", allowPurpose());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(noEnforcePurposeStrategy).allowedByTypeStrategy(PURPOSE, tcString, singletonList(vendorPermissionWitGvl3), excludedVendorPermissionsWithGvl, true);
        verify(basicEnforcePurposeStrategy).allowedByTypeStrategy(PURPOSE, tcString, singletonList(vendorPermissionWitGvl3), excludedVendorPermissionsWithGvl, true);
    }

    private static PrivacyEnforcementAction allowPurposeAndNaturally() {
        return allowNatural(allowPurpose());
    }

    private static PrivacyEnforcementAction allowPurpose() {
        return PrivacyEnforcementAction.restrictAll();
    }

    private static PrivacyEnforcementAction allowNatural() {
        return allowNatural(PrivacyEnforcementAction.restrictAll());
    }

    private static PrivacyEnforcementAction allowNatural(PrivacyEnforcementAction privacyEnforcementAction) {
        privacyEnforcementAction.setRemoveUserIds(false);
        privacyEnforcementAction.setMaskDeviceInfo(false);
        return privacyEnforcementAction;
    }
}

16 Source : PurposeSixStrategyTest.java
with Apache License 2.0
from prebid

public clreplaced PurposeSixStrategyTest {

    private static final org.prebid.server.privacy.gdpr.vendorlist.proto.Purpose PURPOSE = org.prebid.server.privacy.gdpr.vendorlist.proto.Purpose.SIX;

    @Rule
    public final MockitoRule mockitoRule = MockitoJUnit.rule();

    @Mock
    private FullEnforcePurposeStrategy fullEnforcePurposeStrategy;

    @Mock
    private BasicEnforcePurposeStrategy basicEnforcePurposeStrategy;

    @Mock
    private NoEnforcePurposeStrategy noEnforcePurposeStrategy;

    private PurposeSixStrategy target;

    @Mock
    private TCString tcString;

    @Before
    public void setUp() {
        target = new PurposeSixStrategy(fullEnforcePurposeStrategy, basicEnforcePurposeStrategy, noEnforcePurposeStrategy);
    }

    @Test
    public void allowShouldReturnExpectedValue() {
        // given
        final PrivacyEnforcementAction privacyEnforcementAction = PrivacyEnforcementAction.restrictAll();
        // when
        target.allow(privacyEnforcementAction);
        // then
        replacedertThat(privacyEnforcementAction).isEqualToComparingFieldByField(allowPurpose());
    }

    @Test
    public void allowNaturallyShouldReturnExpectedValue() {
        // given
        final PrivacyEnforcementAction privacyEnforcementAction = PrivacyEnforcementAction.restrictAll();
        // when
        target.allowNaturally(privacyEnforcementAction);
        // then
        replacedertThat(privacyEnforcementAction).isEqualToComparingFieldByField(allowNatural());
    }

    @Test
    public void getPurposeIdShouldReturnExpectedValue() {
        // when and then
        replacedertThat(target.getPurpose()).isEqualTo(PURPOSE);
    }

    @Test
    public void processTypePurposeStrategyShouldPreplacedListWithEnforcementsAndExcludeBiddersToNoType() {
        // given
        final List<String> vendorExceptions = Arrays.asList("b1", "b3");
        final Purpose purpose = Purpose.of(EnforcePurpose.no, false, vendorExceptions);
        final VendorPermission vendorPermission1 = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        given(noEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(Arrays.asList(vendorPermission1, vendorPermission2));
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, false);
        // then
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, null, allowPurpose());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b1", allowPurpose());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, null, PrivacyEnforcementAction.restrictAll());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(noEnforcePurposeStrategy).allowedByTypeStrategy(PURPOSE, tcString, Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl3), singletonList(vendorPermissionWitGvl2), false);
    }

    @Test
    public void processTypePurposeStrategyShouldPreplacedListWithEnforcementsAndExcludeBiddersToBaseType() {
        // given
        final List<String> vendorExceptions = Arrays.asList("b1", "b3");
        final Purpose purpose = Purpose.of(EnforcePurpose.basic, false, vendorExceptions);
        final VendorPermission vendorPermission1 = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        given(basicEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(Arrays.asList(vendorPermission1, vendorPermission2));
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, false);
        // then
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, null, allowPurpose());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b1", allowPurpose());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, null, PrivacyEnforcementAction.restrictAll());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(basicEnforcePurposeStrategy).allowedByTypeStrategy(PURPOSE, tcString, Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl3), singletonList(vendorPermissionWitGvl2), false);
    }

    @Test
    public void processTypePurposeStrategyShouldPreplacedListWithEnforcementsAndExcludeBiddersToFullType() {
        // given
        final Purpose purpose = Purpose.of(EnforcePurpose.basic, null, Arrays.asList("b1", "b2", "b3", "b5", "b7"));
        final VendorPermission vendorPermission1 = VendorPermission.of(1, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b2", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, "b3", PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermission> vendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2, vendorPermission3);
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        given(basicEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(vendorPermissions);
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, false);
        // then
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, "b1", allowPurpose());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b2", allowPurpose());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, "b3", allowPurpose());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(basicEnforcePurposeStrategy).allowedByTypeStrategy(PURPOSE, tcString, emptyList(), vendorPermissionsWithGvl, true);
    }

    @Test
    public void processTypePurposeStrategyShouldPreplacedEmptyListWithFullEnforcementsWhenAllBiddersAreExcluded() {
        // given
        final Purpose purpose = Purpose.of(EnforcePurpose.full, null, Arrays.asList("b1", "b2", "b3", "b5", "b7"));
        final VendorPermission vendorPermission1 = VendorPermission.of(1, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b2", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, "b3", PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermission> vendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2, vendorPermission3);
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        given(fullEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(vendorPermissions);
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, false);
        // then
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, "b1", allowPurposeAndNaturally());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b2", allowPurposeAndNaturally());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, "b3", allowPurposeAndNaturally());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(fullEnforcePurposeStrategy, times(2)).allowedByTypeStrategy(PURPOSE, tcString, emptyList(), vendorPermissionsWithGvl, true);
    }

    @Test
    public void processTypePurposeStrategyShouldAllowPurposeAndNaturallyVendorExceptions() {
        // given
        final Purpose purpose = Purpose.of(EnforcePurpose.full, null, Arrays.asList("b1", "b2"));
        final VendorPermission vendorPermission1 = VendorPermission.of(1, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b2", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, "b3", PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermission> vendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2, vendorPermission3);
        final List<VendorPermission> excludedVendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2);
        given(fullEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(vendorPermissions).willReturn(excludedVendorPermissions);
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, false);
        // then
        final List<VendorPermissionWithGvl> excludedVendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2);
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, "b1", allowPurposeAndNaturally());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b2", allowPurposeAndNaturally());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, "b3", allowPurpose());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(fullEnforcePurposeStrategy, times(2)).allowedByTypeStrategy(PURPOSE, tcString, singletonList(vendorPermissionWitGvl3), excludedVendorPermissionsWithGvl, true);
    }

    @Test
    public void processTypePurposeStrategyShouldAllowPurposeAndNaturallyWhenVendorPermissionsReturnedForDowngraded() {
        // given
        final Purpose purpose = Purpose.of(EnforcePurpose.no, null, Arrays.asList("b1", "b2"));
        final VendorPermission vendorPermission1 = VendorPermission.of(1, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b2", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, "b3", PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermission> vendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2, vendorPermission3);
        final List<VendorPermission> excludedVendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2);
        given(noEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(vendorPermissions);
        given(basicEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(excludedVendorPermissions);
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, true);
        // then
        final List<VendorPermissionWithGvl> excludedVendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2);
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, "b1", allowPurposeAndNaturally());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b2", allowPurposeAndNaturally());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, "b3", allowPurpose());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(noEnforcePurposeStrategy).allowedByTypeStrategy(PURPOSE, tcString, singletonList(vendorPermissionWitGvl3), excludedVendorPermissionsWithGvl, true);
        verify(basicEnforcePurposeStrategy).allowedByTypeStrategy(PURPOSE, tcString, singletonList(vendorPermissionWitGvl3), excludedVendorPermissionsWithGvl, true);
    }

    private static PrivacyEnforcementAction allowPurposeAndNaturally() {
        return allowNatural(allowPurpose());
    }

    private static PrivacyEnforcementAction allowPurpose() {
        return PrivacyEnforcementAction.restrictAll();
    }

    private static PrivacyEnforcementAction allowNatural() {
        return allowNatural(PrivacyEnforcementAction.restrictAll());
    }

    private static PrivacyEnforcementAction allowNatural(PrivacyEnforcementAction privacyEnforcementAction) {
        privacyEnforcementAction.setRemoveUserIds(false);
        privacyEnforcementAction.setMaskDeviceInfo(false);
        return privacyEnforcementAction;
    }
}

16 Source : PurposeSevenStrategyTest.java
with Apache License 2.0
from prebid

public clreplaced PurposeSevenStrategyTest {

    private static final org.prebid.server.privacy.gdpr.vendorlist.proto.Purpose PURPOSE = org.prebid.server.privacy.gdpr.vendorlist.proto.Purpose.SEVEN;

    @Rule
    public final MockitoRule mockitoRule = MockitoJUnit.rule();

    @Mock
    private FullEnforcePurposeStrategy fullEnforcePurposeStrategy;

    @Mock
    private BasicEnforcePurposeStrategy basicEnforcePurposeStrategy;

    @Mock
    private NoEnforcePurposeStrategy noEnforcePurposeStrategy;

    private PurposeSevenStrategy target;

    @Mock
    private TCString tcString;

    @Before
    public void setUp() {
        target = new PurposeSevenStrategy(fullEnforcePurposeStrategy, basicEnforcePurposeStrategy, noEnforcePurposeStrategy);
    }

    @Test
    public void allowShouldReturnExpectedValue() {
        // given
        final PrivacyEnforcementAction privacyEnforcementAction = PrivacyEnforcementAction.restrictAll();
        // when
        target.allow(privacyEnforcementAction);
        // then
        replacedertThat(privacyEnforcementAction).isEqualToComparingFieldByField(allowPurpose());
    }

    @Test
    public void allowNaturallyShouldReturnExpectedValue() {
        // given
        final PrivacyEnforcementAction privacyEnforcementAction = PrivacyEnforcementAction.restrictAll();
        // when
        target.allowNaturally(privacyEnforcementAction);
        // then
        replacedertThat(privacyEnforcementAction).isEqualToComparingFieldByField(allowNatural());
    }

    @Test
    public void getPurposeIdShouldReturnExpectedValue() {
        // when and then
        replacedertThat(target.getPurpose()).isEqualTo(PURPOSE);
    }

    @Test
    public void processTypePurposeStrategyShouldPreplacedListWithEnforcementsAndExcludeBiddersToNoType() {
        // given
        final List<String> vendorExceptions = Arrays.asList("b1", "b3");
        final Purpose purpose = Purpose.of(EnforcePurpose.no, false, vendorExceptions);
        final VendorPermission vendorPermission1 = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        given(noEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(Arrays.asList(vendorPermission1, vendorPermission2));
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, false);
        // then
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, null, allowPurpose());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b1", allowPurpose());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, null, PrivacyEnforcementAction.restrictAll());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(noEnforcePurposeStrategy).allowedByTypeStrategy(PURPOSE, tcString, Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl3), singletonList(vendorPermissionWitGvl2), false);
    }

    @Test
    public void processTypePurposeStrategyShouldPreplacedListWithEnforcementsAndExcludeBiddersToBaseType() {
        // given
        final List<String> vendorExceptions = Arrays.asList("b1", "b3");
        final Purpose purpose = Purpose.of(EnforcePurpose.basic, false, vendorExceptions);
        final VendorPermission vendorPermission1 = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        given(basicEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(Arrays.asList(vendorPermission1, vendorPermission2));
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, false);
        // then
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, null, allowPurpose());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b1", allowPurpose());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, null, PrivacyEnforcementAction.restrictAll());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(basicEnforcePurposeStrategy).allowedByTypeStrategy(PURPOSE, tcString, Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl3), singletonList(vendorPermissionWitGvl2), false);
    }

    @Test
    public void processTypePurposeStrategyShouldPreplacedEmptyListWithEnforcementsWhenAllBiddersAreExcluded() {
        // given
        final List<String> vendorExceptions = Arrays.asList("b1", "b2", "b3", "b5", "b7");
        final Purpose purpose = Purpose.of(EnforcePurpose.basic, null, vendorExceptions);
        final VendorPermission vendorPermission1 = VendorPermission.of(1, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b2", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, "b3", PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermission> vendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2, vendorPermission3);
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        given(basicEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(vendorPermissions);
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, false);
        // then
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, "b1", allowPurpose());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b2", allowPurpose());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, "b3", allowPurpose());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(basicEnforcePurposeStrategy).allowedByTypeStrategy(PURPOSE, tcString, emptyList(), vendorPermissionsWithGvl, true);
    }

    @Test
    public void processTypePurposeStrategyShouldPreplacedEmptyListWithFullEnforcementsWhenAllBiddersAreExcluded() {
        // given
        final Purpose purpose = Purpose.of(EnforcePurpose.full, null, Arrays.asList("b1", "b2", "b3", "b5", "b7"));
        final VendorPermission vendorPermission1 = VendorPermission.of(1, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b2", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, "b3", PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermission> vendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2, vendorPermission3);
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        given(fullEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(vendorPermissions);
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, false);
        // then
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, "b1", allowPurposeAndNaturally());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b2", allowPurposeAndNaturally());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, "b3", allowPurposeAndNaturally());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(fullEnforcePurposeStrategy, times(2)).allowedByTypeStrategy(PURPOSE, tcString, emptyList(), vendorPermissionsWithGvl, true);
    }

    @Test
    public void processTypePurposeStrategyShouldAllowPurposeAndNaturallyVendorExceptions() {
        // given
        final Purpose purpose = Purpose.of(EnforcePurpose.full, null, Arrays.asList("b1", "b2"));
        final VendorPermission vendorPermission1 = VendorPermission.of(1, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b2", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, "b3", PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermission> vendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2, vendorPermission3);
        final List<VendorPermission> excludedVendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2);
        given(fullEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(vendorPermissions).willReturn(excludedVendorPermissions);
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, false);
        // then
        final List<VendorPermissionWithGvl> excludedVendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2);
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, "b1", allowPurposeAndNaturally());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b2", allowPurposeAndNaturally());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, "b3", allowPurpose());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(fullEnforcePurposeStrategy, times(2)).allowedByTypeStrategy(PURPOSE, tcString, singletonList(vendorPermissionWitGvl3), excludedVendorPermissionsWithGvl, true);
    }

    @Test
    public void processTypePurposeStrategyShouldAllowPurposeAndNaturallyWhenVendorPermissionsReturnedForDowngraded() {
        // given
        final Purpose purpose = Purpose.of(EnforcePurpose.no, null, Arrays.asList("b1", "b2"));
        final VendorPermission vendorPermission1 = VendorPermission.of(1, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b2", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, "b3", PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermission> vendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2, vendorPermission3);
        final List<VendorPermission> excludedVendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2);
        given(noEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(vendorPermissions);
        given(basicEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(excludedVendorPermissions);
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, true);
        // then
        final List<VendorPermissionWithGvl> excludedVendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2);
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, "b1", allowPurposeAndNaturally());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b2", allowPurposeAndNaturally());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, "b3", allowPurpose());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(noEnforcePurposeStrategy).allowedByTypeStrategy(PURPOSE, tcString, singletonList(vendorPermissionWitGvl3), excludedVendorPermissionsWithGvl, true);
        verify(basicEnforcePurposeStrategy).allowedByTypeStrategy(PURPOSE, tcString, singletonList(vendorPermissionWitGvl3), excludedVendorPermissionsWithGvl, true);
    }

    private static PrivacyEnforcementAction allowPurposeAndNaturally() {
        return allowNatural(allowPurpose());
    }

    private static PrivacyEnforcementAction allowPurpose() {
        final PrivacyEnforcementAction privacyEnforcementAction = PrivacyEnforcementAction.restrictAll();
        privacyEnforcementAction.setBlockreplacedyticsReport(false);
        return privacyEnforcementAction;
    }

    private static PrivacyEnforcementAction allowNatural() {
        return allowNatural(PrivacyEnforcementAction.restrictAll());
    }

    private static PrivacyEnforcementAction allowNatural(PrivacyEnforcementAction privacyEnforcementAction) {
        privacyEnforcementAction.setRemoveUserIds(false);
        privacyEnforcementAction.setMaskDeviceInfo(false);
        return privacyEnforcementAction;
    }
}

16 Source : PurposeOneStrategyTest.java
with Apache License 2.0
from prebid

public clreplaced PurposeOneStrategyTest {

    private static final org.prebid.server.privacy.gdpr.vendorlist.proto.Purpose PURPOSE = org.prebid.server.privacy.gdpr.vendorlist.proto.Purpose.ONE;

    @Rule
    public final MockitoRule mockitoRule = MockitoJUnit.rule();

    @Mock
    private FullEnforcePurposeStrategy fullEnforcePurposeStrategy;

    @Mock
    private BasicEnforcePurposeStrategy basicEnforcePurposeStrategy;

    @Mock
    private NoEnforcePurposeStrategy noEnforcePurposeStrategy;

    private PurposeOneStrategy target;

    @Mock
    private TCString tcString;

    @Before
    public void setUp() {
        target = new PurposeOneStrategy(fullEnforcePurposeStrategy, basicEnforcePurposeStrategy, noEnforcePurposeStrategy);
    }

    @Test
    public void allowShouldReturnExpectedValue() {
        // given
        final PrivacyEnforcementAction privacyEnforcementAction = PrivacyEnforcementAction.restrictAll();
        // when
        target.allow(privacyEnforcementAction);
        // then
        replacedertThat(privacyEnforcementAction).isEqualToComparingFieldByField(allowPurpose());
    }

    @Test
    public void allowNaturallyShouldReturnExpectedValue() {
        // given
        final PrivacyEnforcementAction privacyEnforcementAction = PrivacyEnforcementAction.restrictAll();
        // when
        target.allowNaturally(privacyEnforcementAction);
        // then
        replacedertThat(privacyEnforcementAction).isEqualToComparingFieldByField(PrivacyEnforcementAction.restrictAll());
    }

    @Test
    public void getPurposeIdShouldReturnExpectedValue() {
        // when and then
        replacedertThat(target.getPurpose()).isEqualTo(PURPOSE);
    }

    @Test
    public void processTypePurposeStrategyShouldPreplacedListWithEnforcementsAndExcludeBiddersToNoType() {
        // given
        final List<String> vendorExceptions = Arrays.asList("b1", "b3");
        final Purpose purpose = Purpose.of(EnforcePurpose.no, false, vendorExceptions);
        final VendorPermission vendorPermission1 = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        given(noEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(Arrays.asList(vendorPermission1, vendorPermission2));
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, false);
        // then
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, null, allowPurpose());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b1", allowPurpose());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, null, PrivacyEnforcementAction.restrictAll());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(noEnforcePurposeStrategy).allowedByTypeStrategy(PURPOSE, tcString, Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl3), singletonList(vendorPermissionWitGvl2), false);
    }

    @Test
    public void processTypePurposeStrategyShouldPreplacedListWithEnforcementsAndExcludeBiddersToBaseType() {
        // given
        final List<String> vendorExceptions = Arrays.asList("b1", "b3");
        final Purpose purpose = Purpose.of(EnforcePurpose.basic, false, vendorExceptions);
        final VendorPermission vendorPermission1 = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        given(basicEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(Arrays.asList(vendorPermission1, vendorPermission2));
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, false);
        // then
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, null, allowPurpose());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b1", allowPurpose());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, null, PrivacyEnforcementAction.restrictAll());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(basicEnforcePurposeStrategy).allowedByTypeStrategy(PURPOSE, tcString, Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl3), singletonList(vendorPermissionWitGvl2), false);
    }

    @Test
    public void processTypePurposeStrategyShouldPreplacedEmptyListWithEnforcementsWhenAllBiddersAreExcluded() {
        // given
        final List<String> vendorExceptions = Arrays.asList("b1", "b2", "b3", "b5", "b7");
        final Purpose purpose = Purpose.of(EnforcePurpose.basic, null, vendorExceptions);
        final VendorPermission vendorPermission1 = VendorPermission.of(1, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b2", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, "b3", PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermission> vendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2, vendorPermission3);
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        given(basicEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(vendorPermissions);
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, false);
        // then
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, "b1", allowPurpose());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b2", allowPurpose());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, "b3", allowPurpose());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(basicEnforcePurposeStrategy).allowedByTypeStrategy(PURPOSE, tcString, emptyList(), vendorPermissionsWithGvl, true);
    }

    @Test
    public void processTypePurposeStrategyShouldPreplacedEmptyListWithFullEnforcementsWhenAllBiddersAreExcluded() {
        // given
        final Purpose purpose = Purpose.of(EnforcePurpose.full, null, Arrays.asList("b1", "b2", "b3", "b5", "b7"));
        final VendorPermission vendorPermission1 = VendorPermission.of(1, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b2", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, "b3", PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermission> vendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2, vendorPermission3);
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        given(fullEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(vendorPermissions);
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, false);
        // then
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, "b1", allowPurposeAndNaturally());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b2", allowPurposeAndNaturally());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, "b3", allowPurposeAndNaturally());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(fullEnforcePurposeStrategy, times(2)).allowedByTypeStrategy(PURPOSE, tcString, emptyList(), vendorPermissionsWithGvl, true);
    }

    @Test
    public void processTypePurposeStrategyShouldAllowPurposeAndNaturallyVendorExceptions() {
        // given
        final Purpose purpose = Purpose.of(EnforcePurpose.full, null, Arrays.asList("b1", "b2"));
        final VendorPermission vendorPermission1 = VendorPermission.of(1, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b2", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, "b3", PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermission> vendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2, vendorPermission3);
        final List<VendorPermission> excludedVendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2);
        given(fullEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(vendorPermissions).willReturn(excludedVendorPermissions);
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, false);
        // then
        final List<VendorPermissionWithGvl> excludedVendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2);
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, "b1", allowPurposeAndNaturally());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b2", allowPurposeAndNaturally());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, "b3", allowPurpose());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(fullEnforcePurposeStrategy, times(2)).allowedByTypeStrategy(PURPOSE, tcString, singletonList(vendorPermissionWitGvl3), excludedVendorPermissionsWithGvl, true);
    }

    @Test
    public void processTypePurposeStrategyShouldAllowPurposeAndNaturallyWhenVendorPermissionsReturnedForDowngraded() {
        // given
        final Purpose purpose = Purpose.of(EnforcePurpose.no, null, Arrays.asList("b1", "b2"));
        final VendorPermission vendorPermission1 = VendorPermission.of(1, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b2", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, "b3", PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermission> vendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2, vendorPermission3);
        final List<VendorPermission> excludedVendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2);
        given(noEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(vendorPermissions);
        given(basicEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(excludedVendorPermissions);
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, true);
        // then
        final List<VendorPermissionWithGvl> excludedVendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2);
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, "b1", allowPurposeAndNaturally());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b2", allowPurposeAndNaturally());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, "b3", allowPurpose());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(noEnforcePurposeStrategy).allowedByTypeStrategy(PURPOSE, tcString, singletonList(vendorPermissionWitGvl3), excludedVendorPermissionsWithGvl, true);
        verify(basicEnforcePurposeStrategy).allowedByTypeStrategy(PURPOSE, tcString, singletonList(vendorPermissionWitGvl3), excludedVendorPermissionsWithGvl, true);
    }

    private static PrivacyEnforcementAction allowPurpose() {
        final PrivacyEnforcementAction privacyEnforcementAction = PrivacyEnforcementAction.restrictAll();
        privacyEnforcementAction.setBlockPixelSync(false);
        return privacyEnforcementAction;
    }

    private static PrivacyEnforcementAction allowPurposeAndNaturally() {
        return allowPurpose();
    }
}

16 Source : PurposeNineStrategyTest.java
with Apache License 2.0
from prebid

public clreplaced PurposeNineStrategyTest {

    private static final org.prebid.server.privacy.gdpr.vendorlist.proto.Purpose PURPOSE = org.prebid.server.privacy.gdpr.vendorlist.proto.Purpose.NINE;

    @Rule
    public final MockitoRule mockitoRule = MockitoJUnit.rule();

    @Mock
    private FullEnforcePurposeStrategy fullEnforcePurposeStrategy;

    @Mock
    private BasicEnforcePurposeStrategy basicEnforcePurposeStrategy;

    @Mock
    private NoEnforcePurposeStrategy noEnforcePurposeStrategy;

    private PurposeNineStrategy target;

    @Mock
    private TCString tcString;

    @Before
    public void setUp() {
        target = new PurposeNineStrategy(fullEnforcePurposeStrategy, basicEnforcePurposeStrategy, noEnforcePurposeStrategy);
    }

    @Test
    public void allowShouldReturnExpectedValue() {
        // given
        final PrivacyEnforcementAction privacyEnforcementAction = PrivacyEnforcementAction.restrictAll();
        // when
        target.allow(privacyEnforcementAction);
        // then
        replacedertThat(privacyEnforcementAction).isEqualToComparingFieldByField(allowPurpose());
    }

    @Test
    public void allowNaturallyShouldReturnExpectedValue() {
        // given
        final PrivacyEnforcementAction privacyEnforcementAction = PrivacyEnforcementAction.restrictAll();
        // when
        target.allowNaturally(privacyEnforcementAction);
        // then
        replacedertThat(privacyEnforcementAction).isEqualToComparingFieldByField(allowNatural());
    }

    @Test
    public void getPurposeIdShouldReturnExpectedValue() {
        // when and then
        replacedertThat(target.getPurpose()).isEqualTo(PURPOSE);
    }

    @Test
    public void processTypePurposeStrategyShouldPreplacedListWithEnforcementsAndExcludeBiddersToNoType() {
        // given
        final List<String> vendorExceptions = Arrays.asList("b1", "b3");
        final Purpose purpose = Purpose.of(EnforcePurpose.no, false, vendorExceptions);
        final VendorPermission vendorPermission1 = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        given(noEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(Arrays.asList(vendorPermission1, vendorPermission2));
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, false);
        // then
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, null, allowPurpose());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b1", allowPurpose());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, null, PrivacyEnforcementAction.restrictAll());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(noEnforcePurposeStrategy).allowedByTypeStrategy(PURPOSE, tcString, Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl3), singletonList(vendorPermissionWitGvl2), false);
    }

    @Test
    public void processTypePurposeStrategyShouldPreplacedListWithEnforcementsAndExcludeBiddersToBaseType() {
        // given
        final List<String> vendorExceptions = Arrays.asList("b1", "b3");
        final Purpose purpose = Purpose.of(EnforcePurpose.basic, false, vendorExceptions);
        final VendorPermission vendorPermission1 = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        given(basicEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(Arrays.asList(vendorPermission1, vendorPermission2));
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, false);
        // then
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, null, allowPurpose());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b1", allowPurpose());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, null, PrivacyEnforcementAction.restrictAll());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(basicEnforcePurposeStrategy).allowedByTypeStrategy(PURPOSE, tcString, Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl3), singletonList(vendorPermissionWitGvl2), false);
    }

    @Test
    public void processTypePurposeStrategyShouldPreplacedListWithEnforcementsAndExcludeBiddersToFullType() {
        // given
        final Purpose purpose = Purpose.of(EnforcePurpose.basic, null, Arrays.asList("b1", "b2", "b3", "b5", "b7"));
        final VendorPermission vendorPermission1 = VendorPermission.of(1, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b2", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, "b3", PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermission> vendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2, vendorPermission3);
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        given(basicEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(vendorPermissions);
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, false);
        // then
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, "b1", allowPurpose());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b2", allowPurpose());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, "b3", allowPurpose());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(basicEnforcePurposeStrategy).allowedByTypeStrategy(PURPOSE, tcString, emptyList(), vendorPermissionsWithGvl, true);
    }

    @Test
    public void processTypePurposeStrategyShouldPreplacedEmptyListWithFullEnforcementsWhenAllBiddersAreExcluded() {
        // given
        final Purpose purpose = Purpose.of(EnforcePurpose.full, null, Arrays.asList("b1", "b2", "b3", "b5", "b7"));
        final VendorPermission vendorPermission1 = VendorPermission.of(1, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b2", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, "b3", PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermission> vendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2, vendorPermission3);
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        given(fullEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(vendorPermissions);
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, false);
        // then
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, "b1", allowPurposeAndNaturally());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b2", allowPurposeAndNaturally());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, "b3", allowPurposeAndNaturally());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(fullEnforcePurposeStrategy, times(2)).allowedByTypeStrategy(PURPOSE, tcString, emptyList(), vendorPermissionsWithGvl, true);
    }

    @Test
    public void processTypePurposeStrategyShouldAllowPurposeAndNaturallyVendorExceptions() {
        // given
        final Purpose purpose = Purpose.of(EnforcePurpose.full, null, Arrays.asList("b1", "b2"));
        final VendorPermission vendorPermission1 = VendorPermission.of(1, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b2", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, "b3", PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermission> vendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2, vendorPermission3);
        final List<VendorPermission> excludedVendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2);
        given(fullEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(vendorPermissions).willReturn(excludedVendorPermissions);
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, false);
        // then
        final List<VendorPermissionWithGvl> excludedVendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2);
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, "b1", allowPurposeAndNaturally());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b2", allowPurposeAndNaturally());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, "b3", allowPurpose());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(fullEnforcePurposeStrategy, times(2)).allowedByTypeStrategy(PURPOSE, tcString, singletonList(vendorPermissionWitGvl3), excludedVendorPermissionsWithGvl, true);
    }

    @Test
    public void processTypePurposeStrategyShouldAllowPurposeAndNaturallyWhenVendorPermissionsReturnedForDowngraded() {
        // given
        final Purpose purpose = Purpose.of(EnforcePurpose.no, null, Arrays.asList("b1", "b2"));
        final VendorPermission vendorPermission1 = VendorPermission.of(1, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b2", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, "b3", PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermission> vendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2, vendorPermission3);
        final List<VendorPermission> excludedVendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2);
        given(noEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(vendorPermissions);
        given(basicEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(excludedVendorPermissions);
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, true);
        // then
        final List<VendorPermissionWithGvl> excludedVendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2);
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, "b1", allowPurposeAndNaturally());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b2", allowPurposeAndNaturally());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, "b3", allowPurpose());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(noEnforcePurposeStrategy).allowedByTypeStrategy(PURPOSE, tcString, singletonList(vendorPermissionWitGvl3), excludedVendorPermissionsWithGvl, true);
        verify(basicEnforcePurposeStrategy).allowedByTypeStrategy(PURPOSE, tcString, singletonList(vendorPermissionWitGvl3), excludedVendorPermissionsWithGvl, true);
    }

    private static PrivacyEnforcementAction allowPurposeAndNaturally() {
        return allowNatural(allowPurpose());
    }

    private static PrivacyEnforcementAction allowPurpose() {
        return PrivacyEnforcementAction.restrictAll();
    }

    private static PrivacyEnforcementAction allowNatural() {
        return allowNatural(PrivacyEnforcementAction.restrictAll());
    }

    private static PrivacyEnforcementAction allowNatural(PrivacyEnforcementAction privacyEnforcementAction) {
        privacyEnforcementAction.setRemoveUserIds(false);
        privacyEnforcementAction.setMaskDeviceInfo(false);
        return privacyEnforcementAction;
    }
}

16 Source : PurposeFourStrategyTest.java
with Apache License 2.0
from prebid

public clreplaced PurposeFourStrategyTest {

    private static final org.prebid.server.privacy.gdpr.vendorlist.proto.Purpose PURPOSE = org.prebid.server.privacy.gdpr.vendorlist.proto.Purpose.FOUR;

    @Rule
    public final MockitoRule mockitoRule = MockitoJUnit.rule();

    @Mock
    private FullEnforcePurposeStrategy fullEnforcePurposeStrategy;

    @Mock
    private BasicEnforcePurposeStrategy basicEnforcePurposeStrategy;

    @Mock
    private NoEnforcePurposeStrategy noEnforcePurposeStrategy;

    private PurposeFourStrategy target;

    @Mock
    private TCString tcString;

    @Before
    public void setUp() {
        target = new PurposeFourStrategy(fullEnforcePurposeStrategy, basicEnforcePurposeStrategy, noEnforcePurposeStrategy);
    }

    @Test
    public void allowShouldReturnExpectedValue() {
        // given
        final PrivacyEnforcementAction privacyEnforcementAction = PrivacyEnforcementAction.restrictAll();
        // when
        target.allow(privacyEnforcementAction);
        // then
        replacedertThat(privacyEnforcementAction).isEqualToComparingFieldByField(allowPurpose());
    }

    @Test
    public void allowNaturallyShouldReturnExpectedValue() {
        // given
        final PrivacyEnforcementAction privacyEnforcementAction = PrivacyEnforcementAction.restrictAll();
        // when
        target.allowNaturally(privacyEnforcementAction);
        // then
        replacedertThat(privacyEnforcementAction).isEqualToComparingFieldByField(allowNatural());
    }

    @Test
    public void getPurposeIdShouldReturnExpectedValue() {
        // when and then
        replacedertThat(target.getPurpose()).isEqualTo(PURPOSE);
    }

    @Test
    public void processTypePurposeStrategyShouldPreplacedListWithEnforcementsAndExcludeBiddersToNoType() {
        // given
        final List<String> vendorExceptions = Arrays.asList("b1", "b3");
        final Purpose purpose = Purpose.of(EnforcePurpose.no, false, vendorExceptions);
        final VendorPermission vendorPermission1 = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        given(noEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(Arrays.asList(vendorPermission1, vendorPermission2));
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, false);
        // then
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, null, allowPurpose());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b1", allowPurpose());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, null, PrivacyEnforcementAction.restrictAll());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(noEnforcePurposeStrategy).allowedByTypeStrategy(PURPOSE, tcString, Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl3), singletonList(vendorPermissionWitGvl2), false);
    }

    @Test
    public void processTypePurposeStrategyShouldPreplacedListWithEnforcementsAndExcludeBiddersToBaseType() {
        // given
        final List<String> vendorExceptions = Arrays.asList("b1", "b3");
        final Purpose purpose = Purpose.of(EnforcePurpose.basic, false, vendorExceptions);
        final VendorPermission vendorPermission1 = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        given(basicEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(Arrays.asList(vendorPermission1, vendorPermission2));
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, false);
        // then
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, null, allowPurpose());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b1", allowPurpose());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, null, PrivacyEnforcementAction.restrictAll());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(basicEnforcePurposeStrategy).allowedByTypeStrategy(PURPOSE, tcString, Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl3), singletonList(vendorPermissionWitGvl2), false);
    }

    @Test
    public void processTypePurposeStrategyShouldPreplacedEmptyListWithEnforcementsWhenAllBiddersAreExcluded() {
        // given
        final List<String> vendorExceptions = Arrays.asList("b1", "b2", "b3", "b5", "b7");
        final Purpose purpose = Purpose.of(EnforcePurpose.basic, null, vendorExceptions);
        final VendorPermission vendorPermission1 = VendorPermission.of(1, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b2", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, "b3", PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermission> vendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2, vendorPermission3);
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        given(basicEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(vendorPermissions);
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, false);
        // then
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, "b1", allowPurpose());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b2", allowPurpose());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, "b3", allowPurpose());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(basicEnforcePurposeStrategy).allowedByTypeStrategy(PURPOSE, tcString, emptyList(), vendorPermissionsWithGvl, true);
    }

    @Test
    public void processTypePurposeStrategyShouldPreplacedEmptyListWithFullEnforcementsWhenAllBiddersAreExcluded() {
        // given
        final Purpose purpose = Purpose.of(EnforcePurpose.full, null, Arrays.asList("b1", "b2", "b3", "b5", "b7"));
        final VendorPermission vendorPermission1 = VendorPermission.of(1, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b2", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, "b3", PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermission> vendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2, vendorPermission3);
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        given(fullEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(vendorPermissions);
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, false);
        // then
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, "b1", allowPurposeAndNaturally());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b2", allowPurposeAndNaturally());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, "b3", allowPurposeAndNaturally());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(fullEnforcePurposeStrategy, times(2)).allowedByTypeStrategy(PURPOSE, tcString, emptyList(), vendorPermissionsWithGvl, true);
    }

    @Test
    public void processTypePurposeStrategyShouldAllowPurposeAndNaturallyVendorExceptions() {
        // given
        final Purpose purpose = Purpose.of(EnforcePurpose.full, null, Arrays.asList("b1", "b2"));
        final VendorPermission vendorPermission1 = VendorPermission.of(1, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b2", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, "b3", PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermission> vendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2, vendorPermission3);
        final List<VendorPermission> excludedVendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2);
        given(fullEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(vendorPermissions).willReturn(excludedVendorPermissions);
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, false);
        // then
        final List<VendorPermissionWithGvl> excludedVendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2);
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, "b1", allowPurposeAndNaturally());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b2", allowPurposeAndNaturally());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, "b3", allowPurpose());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(fullEnforcePurposeStrategy, times(2)).allowedByTypeStrategy(PURPOSE, tcString, singletonList(vendorPermissionWitGvl3), excludedVendorPermissionsWithGvl, true);
    }

    @Test
    public void processTypePurposeStrategyShouldAllowPurposeAndNaturallyWhenVendorPermissionsReturnedForDowngraded() {
        // given
        final Purpose purpose = Purpose.of(EnforcePurpose.no, null, Arrays.asList("b1", "b2"));
        final VendorPermission vendorPermission1 = VendorPermission.of(1, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b2", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, "b3", PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermission> vendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2, vendorPermission3);
        final List<VendorPermission> excludedVendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2);
        given(noEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(vendorPermissions);
        given(basicEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(excludedVendorPermissions);
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, true);
        // then
        final List<VendorPermissionWithGvl> excludedVendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2);
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, "b1", allowPurposeAndNaturally());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b2", allowPurposeAndNaturally());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, "b3", allowPurpose());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(noEnforcePurposeStrategy).allowedByTypeStrategy(PURPOSE, tcString, singletonList(vendorPermissionWitGvl3), excludedVendorPermissionsWithGvl, true);
        verify(basicEnforcePurposeStrategy).allowedByTypeStrategy(PURPOSE, tcString, singletonList(vendorPermissionWitGvl3), excludedVendorPermissionsWithGvl, true);
    }

    private static PrivacyEnforcementAction allowPurposeAndNaturally() {
        return allowNatural(allowPurpose());
    }

    private static PrivacyEnforcementAction allowPurpose() {
        return PrivacyEnforcementAction.restrictAll();
    }

    private static PrivacyEnforcementAction allowNatural() {
        return allowNatural(PrivacyEnforcementAction.restrictAll());
    }

    private static PrivacyEnforcementAction allowNatural(PrivacyEnforcementAction privacyEnforcementAction) {
        privacyEnforcementAction.setRemoveUserIds(false);
        privacyEnforcementAction.setMaskDeviceInfo(false);
        return privacyEnforcementAction;
    }
}

16 Source : PurposeFiveStrategyTest.java
with Apache License 2.0
from prebid

public clreplaced PurposeFiveStrategyTest {

    private static final org.prebid.server.privacy.gdpr.vendorlist.proto.Purpose PURPOSE = org.prebid.server.privacy.gdpr.vendorlist.proto.Purpose.FIVE;

    @Rule
    public final MockitoRule mockitoRule = MockitoJUnit.rule();

    @Mock
    private FullEnforcePurposeStrategy fullEnforcePurposeStrategy;

    @Mock
    private BasicEnforcePurposeStrategy basicEnforcePurposeStrategy;

    @Mock
    private NoEnforcePurposeStrategy noEnforcePurposeStrategy;

    private PurposeFiveStrategy target;

    @Mock
    private TCString tcString;

    @Before
    public void setUp() {
        target = new PurposeFiveStrategy(fullEnforcePurposeStrategy, basicEnforcePurposeStrategy, noEnforcePurposeStrategy);
    }

    @Test
    public void allowShouldReturnExpectedValue() {
        // given
        final PrivacyEnforcementAction privacyEnforcementAction = PrivacyEnforcementAction.restrictAll();
        // when
        target.allow(privacyEnforcementAction);
        // then
        replacedertThat(privacyEnforcementAction).isEqualToComparingFieldByField(allowPurpose());
    }

    @Test
    public void allowNaturallyShouldReturnExpectedValue() {
        // given
        final PrivacyEnforcementAction privacyEnforcementAction = PrivacyEnforcementAction.restrictAll();
        // when
        target.allowNaturally(privacyEnforcementAction);
        // then
        replacedertThat(privacyEnforcementAction).isEqualToComparingFieldByField(allowNatural());
    }

    @Test
    public void getPurposeIdShouldReturnExpectedValue() {
        // when and then
        replacedertThat(target.getPurpose()).isEqualTo(PURPOSE);
    }

    @Test
    public void processTypePurposeStrategyShouldPreplacedListWithEnforcementsAndExcludeBiddersToNoType() {
        // given
        final List<String> vendorExceptions = Arrays.asList("b1", "b3");
        final Purpose purpose = Purpose.of(EnforcePurpose.no, false, vendorExceptions);
        final VendorPermission vendorPermission1 = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        given(noEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(Arrays.asList(vendorPermission1, vendorPermission2));
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, false);
        // then
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, null, allowPurpose());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b1", allowPurpose());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, null, PrivacyEnforcementAction.restrictAll());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(noEnforcePurposeStrategy).allowedByTypeStrategy(PURPOSE, tcString, Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl3), singletonList(vendorPermissionWitGvl2), false);
    }

    @Test
    public void processTypePurposeStrategyShouldPreplacedListWithEnforcementsAndExcludeBiddersToBaseType() {
        // given
        final List<String> vendorExceptions = Arrays.asList("b1", "b3");
        final Purpose purpose = Purpose.of(EnforcePurpose.basic, false, vendorExceptions);
        final VendorPermission vendorPermission1 = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        given(basicEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(Arrays.asList(vendorPermission1, vendorPermission2));
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, false);
        // then
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, null, allowPurpose());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b1", allowPurpose());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, null, PrivacyEnforcementAction.restrictAll());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(basicEnforcePurposeStrategy).allowedByTypeStrategy(PURPOSE, tcString, Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl3), singletonList(vendorPermissionWitGvl2), false);
    }

    @Test
    public void processTypePurposeStrategyShouldPreplacedListWithEnforcementsAndExcludeBiddersToFullType() {
        // given
        final Purpose purpose = Purpose.of(EnforcePurpose.basic, null, Arrays.asList("b1", "b2", "b3", "b5", "b7"));
        final VendorPermission vendorPermission1 = VendorPermission.of(1, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b2", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, "b3", PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermission> vendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2, vendorPermission3);
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        given(basicEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(vendorPermissions);
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, false);
        // then
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, "b1", allowPurpose());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b2", allowPurpose());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, "b3", allowPurpose());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(basicEnforcePurposeStrategy).allowedByTypeStrategy(PURPOSE, tcString, emptyList(), vendorPermissionsWithGvl, true);
    }

    @Test
    public void processTypePurposeStrategyShouldPreplacedEmptyListWithFullEnforcementsWhenAllBiddersAreExcluded() {
        // given
        final Purpose purpose = Purpose.of(EnforcePurpose.full, null, Arrays.asList("b1", "b2", "b3", "b5", "b7"));
        final VendorPermission vendorPermission1 = VendorPermission.of(1, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b2", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, "b3", PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermission> vendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2, vendorPermission3);
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        given(fullEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(vendorPermissions);
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, false);
        // then
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, "b1", allowPurposeAndNaturally());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b2", allowPurposeAndNaturally());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, "b3", allowPurposeAndNaturally());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(fullEnforcePurposeStrategy, times(2)).allowedByTypeStrategy(PURPOSE, tcString, emptyList(), vendorPermissionsWithGvl, true);
    }

    @Test
    public void processTypePurposeStrategyShouldAllowPurposeAndNaturallyVendorExceptions() {
        // given
        final Purpose purpose = Purpose.of(EnforcePurpose.full, null, Arrays.asList("b1", "b2"));
        final VendorPermission vendorPermission1 = VendorPermission.of(1, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b2", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, "b3", PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermission> vendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2, vendorPermission3);
        final List<VendorPermission> excludedVendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2);
        given(fullEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(vendorPermissions).willReturn(excludedVendorPermissions);
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, false);
        // then
        final List<VendorPermissionWithGvl> excludedVendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2);
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, "b1", allowPurposeAndNaturally());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b2", allowPurposeAndNaturally());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, "b3", allowPurpose());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(fullEnforcePurposeStrategy, times(2)).allowedByTypeStrategy(PURPOSE, tcString, singletonList(vendorPermissionWitGvl3), excludedVendorPermissionsWithGvl, true);
    }

    @Test
    public void processTypePurposeStrategyShouldAllowPurposeAndNaturallyWhenVendorPermissionsReturnedForDowngraded() {
        // given
        final Purpose purpose = Purpose.of(EnforcePurpose.no, null, Arrays.asList("b1", "b2"));
        final VendorPermission vendorPermission1 = VendorPermission.of(1, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b2", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, "b3", PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermission> vendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2, vendorPermission3);
        final List<VendorPermission> excludedVendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2);
        given(noEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(vendorPermissions);
        given(basicEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(excludedVendorPermissions);
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, true);
        // then
        final List<VendorPermissionWithGvl> excludedVendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2);
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, "b1", allowPurposeAndNaturally());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b2", allowPurposeAndNaturally());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, "b3", allowPurpose());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(noEnforcePurposeStrategy).allowedByTypeStrategy(PURPOSE, tcString, singletonList(vendorPermissionWitGvl3), excludedVendorPermissionsWithGvl, true);
        verify(basicEnforcePurposeStrategy).allowedByTypeStrategy(PURPOSE, tcString, singletonList(vendorPermissionWitGvl3), excludedVendorPermissionsWithGvl, true);
    }

    private static PrivacyEnforcementAction allowPurposeAndNaturally() {
        return allowNatural(allowPurpose());
    }

    private static PrivacyEnforcementAction allowPurpose() {
        return PrivacyEnforcementAction.restrictAll();
    }

    private static PrivacyEnforcementAction allowNatural() {
        return allowNatural(PrivacyEnforcementAction.restrictAll());
    }

    private static PrivacyEnforcementAction allowNatural(PrivacyEnforcementAction privacyEnforcementAction) {
        privacyEnforcementAction.setRemoveUserIds(false);
        privacyEnforcementAction.setMaskDeviceInfo(false);
        return privacyEnforcementAction;
    }
}

16 Source : PurposeEightStrategyTest.java
with Apache License 2.0
from prebid

public clreplaced PurposeEightStrategyTest {

    private static final org.prebid.server.privacy.gdpr.vendorlist.proto.Purpose PURPOSE = org.prebid.server.privacy.gdpr.vendorlist.proto.Purpose.EIGHT;

    @Rule
    public final MockitoRule mockitoRule = MockitoJUnit.rule();

    @Mock
    private FullEnforcePurposeStrategy fullEnforcePurposeStrategy;

    @Mock
    private BasicEnforcePurposeStrategy basicEnforcePurposeStrategy;

    @Mock
    private NoEnforcePurposeStrategy noEnforcePurposeStrategy;

    private PurposeEightStrategy target;

    @Mock
    private TCString tcString;

    @Before
    public void setUp() {
        target = new PurposeEightStrategy(fullEnforcePurposeStrategy, basicEnforcePurposeStrategy, noEnforcePurposeStrategy);
    }

    @Test
    public void allowShouldReturnExpectedValue() {
        // given
        final PrivacyEnforcementAction privacyEnforcementAction = PrivacyEnforcementAction.restrictAll();
        // when
        target.allow(privacyEnforcementAction);
        // then
        replacedertThat(privacyEnforcementAction).isEqualToComparingFieldByField(allowPurpose());
    }

    @Test
    public void allowNaturallyShouldReturnExpectedValue() {
        // given
        final PrivacyEnforcementAction privacyEnforcementAction = PrivacyEnforcementAction.restrictAll();
        // when
        target.allowNaturally(privacyEnforcementAction);
        // then
        replacedertThat(privacyEnforcementAction).isEqualToComparingFieldByField(allowNatural());
    }

    @Test
    public void getPurposeIdShouldReturnExpectedValue() {
        // when and then
        replacedertThat(target.getPurpose()).isEqualTo(PURPOSE);
    }

    @Test
    public void processTypePurposeStrategyShouldPreplacedListWithEnforcementsAndExcludeBiddersToNoType() {
        // given
        final List<String> vendorExceptions = Arrays.asList("b1", "b3");
        final Purpose purpose = Purpose.of(EnforcePurpose.no, false, vendorExceptions);
        final VendorPermission vendorPermission1 = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        given(noEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(Arrays.asList(vendorPermission1, vendorPermission2));
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, false);
        // then
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, null, allowPurpose());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b1", allowPurpose());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, null, PrivacyEnforcementAction.restrictAll());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(noEnforcePurposeStrategy).allowedByTypeStrategy(PURPOSE, tcString, Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl3), singletonList(vendorPermissionWitGvl2), false);
    }

    @Test
    public void processTypePurposeStrategyShouldPreplacedListWithEnforcementsAndExcludeBiddersToBaseType() {
        // given
        final List<String> vendorExceptions = Arrays.asList("b1", "b3");
        final Purpose purpose = Purpose.of(EnforcePurpose.basic, false, vendorExceptions);
        final VendorPermission vendorPermission1 = VendorPermission.of(1, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, null, PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        given(basicEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(Arrays.asList(vendorPermission1, vendorPermission2));
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, false);
        // then
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, null, allowPurpose());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b1", allowPurpose());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, null, PrivacyEnforcementAction.restrictAll());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(basicEnforcePurposeStrategy).allowedByTypeStrategy(PURPOSE, tcString, Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl3), singletonList(vendorPermissionWitGvl2), false);
    }

    @Test
    public void processTypePurposeStrategyShouldPreplacedListWithEnforcementsAndExcludeBiddersToFullType() {
        // given
        final Purpose purpose = Purpose.of(EnforcePurpose.basic, null, Arrays.asList("b1", "b2", "b3", "b5", "b7"));
        final VendorPermission vendorPermission1 = VendorPermission.of(1, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b2", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, "b3", PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermission> vendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2, vendorPermission3);
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        given(basicEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(vendorPermissions);
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, false);
        // then
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, "b1", allowPurpose());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b2", allowPurpose());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, "b3", allowPurpose());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(basicEnforcePurposeStrategy).allowedByTypeStrategy(PURPOSE, tcString, emptyList(), vendorPermissionsWithGvl, true);
    }

    @Test
    public void processTypePurposeStrategyShouldPreplacedEmptyListWithFullEnforcementsWhenAllBiddersAreExcluded() {
        // given
        final Purpose purpose = Purpose.of(EnforcePurpose.full, null, Arrays.asList("b1", "b2", "b3", "b5", "b7"));
        final VendorPermission vendorPermission1 = VendorPermission.of(1, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b2", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, "b3", PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermission> vendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2, vendorPermission3);
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        given(fullEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(vendorPermissions);
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, false);
        // then
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, "b1", allowPurposeAndNaturally());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b2", allowPurposeAndNaturally());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, "b3", allowPurposeAndNaturally());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(fullEnforcePurposeStrategy, times(2)).allowedByTypeStrategy(PURPOSE, tcString, emptyList(), vendorPermissionsWithGvl, true);
    }

    @Test
    public void processTypePurposeStrategyShouldAllowPurposeAndNaturallyVendorExceptions() {
        // given
        final Purpose purpose = Purpose.of(EnforcePurpose.full, null, Arrays.asList("b1", "b2"));
        final VendorPermission vendorPermission1 = VendorPermission.of(1, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b2", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, "b3", PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermission> vendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2, vendorPermission3);
        final List<VendorPermission> excludedVendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2);
        given(fullEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(vendorPermissions).willReturn(excludedVendorPermissions);
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, false);
        // then
        final List<VendorPermissionWithGvl> excludedVendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2);
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, "b1", allowPurposeAndNaturally());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b2", allowPurposeAndNaturally());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, "b3", allowPurpose());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(fullEnforcePurposeStrategy, times(2)).allowedByTypeStrategy(PURPOSE, tcString, singletonList(vendorPermissionWitGvl3), excludedVendorPermissionsWithGvl, true);
    }

    @Test
    public void processTypePurposeStrategyShouldAllowPurposeAndNaturallyWhenVendorPermissionsReturnedForDowngraded() {
        // given
        final Purpose purpose = Purpose.of(EnforcePurpose.no, null, Arrays.asList("b1", "b2"));
        final VendorPermission vendorPermission1 = VendorPermission.of(1, "b1", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission2 = VendorPermission.of(2, "b2", PrivacyEnforcementAction.restrictAll());
        final VendorPermission vendorPermission3 = VendorPermission.of(3, "b3", PrivacyEnforcementAction.restrictAll());
        final VendorPermissionWithGvl vendorPermissionWitGvl1 = VendorPermissionWithGvl.of(vendorPermission1, VendorV2.empty(1));
        final VendorPermissionWithGvl vendorPermissionWitGvl2 = VendorPermissionWithGvl.of(vendorPermission2, VendorV2.empty(2));
        final VendorPermissionWithGvl vendorPermissionWitGvl3 = VendorPermissionWithGvl.of(vendorPermission3, VendorV2.empty(3));
        final List<VendorPermission> vendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2, vendorPermission3);
        final List<VendorPermission> excludedVendorPermissions = Arrays.asList(vendorPermission1, vendorPermission2);
        given(noEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(vendorPermissions);
        given(basicEnforcePurposeStrategy.allowedByTypeStrategy(any(), any(), any(), any(), anyBoolean())).willReturn(excludedVendorPermissions);
        final List<VendorPermissionWithGvl> vendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2, vendorPermissionWitGvl3);
        // when
        final Collection<VendorPermission> result = target.processTypePurposeStrategy(tcString, purpose, vendorPermissionsWithGvl, true);
        // then
        final List<VendorPermissionWithGvl> excludedVendorPermissionsWithGvl = Arrays.asList(vendorPermissionWitGvl1, vendorPermissionWitGvl2);
        final VendorPermission vendorPermission1Changed = VendorPermission.of(1, "b1", allowPurposeAndNaturally());
        final VendorPermission vendorPermission2Changed = VendorPermission.of(2, "b2", allowPurposeAndNaturally());
        final VendorPermission vendorPermission3Changed = VendorPermission.of(3, "b3", allowPurpose());
        replacedertThat(result).usingFieldByFieldElementComparator().isEqualTo(Arrays.asList(vendorPermission1Changed, vendorPermission2Changed, vendorPermission3Changed));
        verify(noEnforcePurposeStrategy).allowedByTypeStrategy(PURPOSE, tcString, singletonList(vendorPermissionWitGvl3), excludedVendorPermissionsWithGvl, true);
        verify(basicEnforcePurposeStrategy).allowedByTypeStrategy(PURPOSE, tcString, singletonList(vendorPermissionWitGvl3), excludedVendorPermissionsWithGvl, true);
    }

    private static PrivacyEnforcementAction allowPurposeAndNaturally() {
        return allowNatural(allowPurpose());
    }

    private static PrivacyEnforcementAction allowPurpose() {
        return PrivacyEnforcementAction.restrictAll();
    }

    private static PrivacyEnforcementAction allowNatural() {
        return allowNatural(PrivacyEnforcementAction.restrictAll());
    }

    private static PrivacyEnforcementAction allowNatural(PrivacyEnforcementAction privacyEnforcementAction) {
        privacyEnforcementAction.setRemoveUserIds(false);
        privacyEnforcementAction.setMaskDeviceInfo(false);
        return privacyEnforcementAction;
    }
}

16 Source : SpecialFeaturesStrategy.java
with Apache License 2.0
from prebid

public Collection<VendorPermission> processSpecialFeaturesStrategy(TCString vendorConsent, SpecialFeature specialFeature, Collection<VendorPermission> vendorPermissions) {
    // Default True
    if (BooleanUtils.isFalse(specialFeature.getEnforce())) {
        return allowFor(vendorPermissions);
    }
    final Inreplacederable specialFeatureOptIns = vendorConsent.getSpecialFeatureOptIns();
    final boolean isSpecialFeatureIsOptIn = specialFeatureOptIns.contains(getSpecialFeatureId());
    return isSpecialFeatureIsOptIn ? allowFor(vendorPermissions) : allowOnlyExcluded(vendorPermissions, specialFeature);
}

16 Source : PurposeTwoBasicEnforcePurposeStrategy.java
with Apache License 2.0
from prebid

private boolean isAllowedBySimpleConsentOrPurposeLI(Purpose purpose, Integer vendorId, boolean isEnforceVendor, TCString tcString) {
    final Inreplacederable purposesLIConsent = tcString.getPurposesLITransparency();
    return isAllowedBySimpleConsent(purpose, vendorId, isEnforceVendor, tcString) || purposesLIConsent.contains(purpose.code());
}

16 Source : FullEnforcePurposeStrategy.java
with Apache License 2.0
from prebid

public Collection<VendorPermission> allowedByTypeStrategy(Purpose purpose, TCString vendorConsent, Collection<VendorPermissionWithGvl> vendorsForPurpose, Collection<VendorPermissionWithGvl> excludedVendors, boolean isEnforceVendors) {
    final List<PublisherRestriction> publisherRestrictions = vendorConsent.getPublisherRestrictions().stream().filter(publisherRestriction -> publisherRestriction.getPurposeId() == purpose.code()).collect(Collectors.toList());
    final List<VendorPermission> allowedExcluded = allowedExcludedVendorPermission(excludedVendors, publisherRestrictions);
    final Map<VendorPermissionWithGvl, RestrictionType> vendorPermissionToRestriction = mapVendorPermission(vendorsForPurpose, publisherRestrictions);
    final List<VendorPermission> allowedVendorPermissions = vendorPermissionToRestriction.entrySet().stream().filter(permissionAndRestriction -> isAllowedByPublisherRestrictionAndFlexible(purpose, isEnforceVendors, permissionAndRestriction.getKey(), vendorConsent, permissionAndRestriction.getValue())).map(Map.Entry::getKey).map(VendorPermissionWithGvl::getVendorPermission).collect(Collectors.toList());
    return CollectionUtils.union(allowedExcluded, allowedVendorPermissions);
}

16 Source : EnforcePurposeStrategy.java
with Apache License 2.0
from prebid

protected boolean isAllowedBySimpleConsent(Purpose purpose, Integer vendorId, boolean isEnforceVendor, TCString tcString) {
    final Inreplacederable purposesConsent = tcString.getPurposesConsent();
    final Inreplacederable vendorConsent = tcString.getVendorConsent();
    return isAllowedByConsents(purpose, vendorId, isEnforceVendor, purposesConsent, vendorConsent);
}

16 Source : Tcf2Service.java
with Apache License 2.0
from prebid

private Collection<VendorPermission> processSupportedSpecialFeatureStrategies(TCString tcfConsent, Collection<VendorPermission> vendorPermissions, SpecialFeatures specialFeatures) {
    for (SpecialFeaturesStrategy specialFeaturesStrategy : specialFeaturesStrategies) {
        final int specialFeatureId = specialFeaturesStrategy.getSpecialFeatureId();
        final SpecialFeature specialFeatureById = findSpecialFeatureById(specialFeatureId, specialFeatures);
        specialFeaturesStrategy.processSpecialFeaturesStrategy(tcfConsent, specialFeatureById, vendorPermissions);
    }
    return vendorPermissions;
}

See More Examples