iabconsent/parsed_consent_test.go at master · adayNU/iabconsent · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
package iabconsent

import (
	"sort"

	"github.com/go-check/check"
)

type ParsedConsentSuite struct{}

func (p *ParsedConsentSuite) TestErrorCases(c *check.C) {
	var cases = []struct {
		EncodedString string
		Error         string
	}{
		{
			EncodedString: "//BONJ5bvONJ5bvAMAPyFRAL7AAAAMhuqKklS-gAAAAAAAAAAAAAAAAAAAAAAAAAA",
			Error:         "illegal base64 data at input byte 0",
		},
		{
			// base64.RawURLEncoding.EncodeToString([]byte("10011010110110101"))
			EncodedString: "MTAwMTEwMTAxMTAxMTAxMDE",
			Error:         "index out of range",
		},
	}

	for _, tc := range cases {
		c.Log(tc.EncodedString)
		_, err := Parse(tc.EncodedString)
		c.Check(err.Error(), check.Equals, tc.Error)
	}
}

func (p *ParsedConsentSuite) TestParseConsentStrings(c *check.C) {
	var cases = []struct {
		Type          consentType
		EncodedString string
	}{
		{
			Type:          BitField,
			EncodedString: "BONMj34ONMj34ABACDENALqAAAAAplY",
		},
		{
			Type:          SingleRangeWithSingleID,
			EncodedString: "BONMj34ONMj34ABACDENALqAAAAAqABAD2AAAAAAAAAAAAAAAAAAAAAAAAAA",
		},
		{
			Type:          SingleRangeWithRange,
			EncodedString: "BONMj34ONMj34ABACDENALqAAAAAqABgD2AdQAAAAAAAAAAAAAAAAAAAAAAAAAA",
		},
		{
			Type:          MultipleRangesWithSingleID,
			EncodedString: "BONMj34ONMj34ABACDENALqAAAAAqACAD2AOoAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
		},
		{
			Type:          MultipleRangesWithRange,
			EncodedString: "BONMj34ONMj34ABACDENALqAAAAAqACgD2AdUBWQHIAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
		},
		{
			Type:          MultipleRangesMixed,
			EncodedString: "BONMj34ONMj34ABACDENALqAAAAAqACAD3AVkByAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
		},
	}

	for _, tc := range cases {
		c.Log(tc)
		pc, err := Parse(tc.EncodedString)
		c.Check(err, check.IsNil)

		normalizeParsedConsent(pc)
		normalizeParsedConsent(consentFixtures[tc.Type])

		c.Assert(pc, check.DeepEquals, consentFixtures[tc.Type])
	}
}

func (p *ParsedConsentSuite) TestGetMethods(c *check.C) {
	pc := consentFixtures[BitField]
	c.Check(pc.ConsentString(), check.Equals, pc.consentString)
	c.Check(pc.Version(), check.Equals, pc.version)
	c.Check(pc.Created(), check.Equals, pc.created)
	c.Check(pc.LastUpdated(), check.Equals, pc.lastUpdated)
	c.Check(pc.CmpID(), check.Equals, pc.cmpID)
	c.Check(pc.CmpVersion(), check.Equals, pc.cmpVersion)
	c.Check(pc.ConsentScreen(), check.Equals, pc.consentScreen)
	c.Check(pc.ConsentLanguage(), check.Equals, pc.consentLanguage)
	c.Check(pc.VendorListVersion(), check.Equals, pc.vendorListVersion)
	c.Check(pc.MaxVendorID(), check.Equals, pc.maxVendorID)
}

func (p *ParsedConsentSuite) TestPurposeAllowed(c *check.C) {
	pc := consentFixtures[BitField]
	c.Check(pc.PurposeAllowed(1), check.Equals, true)
	c.Check(pc.PurposeAllowed(2), check.Equals, false)
}

func (p *ParsedConsentSuite) TestPurposesAllowed(c *check.C) {
	pc := consentFixtures[BitField]

	c.Check(pc.PurposesAllowed([]int{1, 3}), check.Equals, true)
	c.Check(pc.PurposesAllowed([]int{1, 4}), check.Equals, false)
}

func (p *ParsedConsentSuite) TestVendorAllowed(c *check.C) {
	pc := consentFixtures[BitField]

	c.Check(pc.VendorAllowed(1), check.Equals, true)
	c.Check(pc.VendorAllowed(3), check.Equals, false)

	pc = consentFixtures[MultipleRangesMixed]

	c.Check(pc.VendorAllowed(123), check.Equals, true)
	c.Check(pc.VendorAllowed(345), check.Equals, true)
	c.Check(pc.VendorAllowed(400), check.Equals, true)
	c.Check(pc.VendorAllowed(456), check.Equals, true)

	c.Check(pc.VendorAllowed(1), check.Equals, false)
	c.Check(pc.VendorAllowed(150), check.Equals, false)
	c.Check(pc.VendorAllowed(500), check.Equals, false)
}

func normalizeParsedConsent(p *ParsedConsent) {
	sort.Slice(p.rangeEntries, func(i, j int) bool {
		return p.rangeEntries[i].StartVendorID < p.rangeEntries[j].StartVendorID
	})
}

var _ = check.Suite(&ParsedConsentSuite{})