xref: /aosp_15_r20/external/spdx-tools/spdx/common/identifier_test.go (revision ba677afa8f67bb56cbc794f4d0e378e0da058e16) 
1package common
2
3import (
4	"encoding/json"
5	"fmt"
6	"reflect"
7	"strings"
8	"testing"
9)
10
11func Test_DocElementIDEncoding(t *testing.T) {
12	tests := []struct {
13		name     string
14		value    DocElementID
15		expected string
16		err      bool
17	}{
18		{
19			name: "ElementRefID",
20			value: DocElementID{
21				ElementRefID: "some-id",
22			},
23			expected: "SPDXRef-some-id",
24		},
25		{
26			name: "DocumentRefID:ElementRefID",
27			value: DocElementID{
28				DocumentRefID: "a-doc",
29				ElementRefID:  "some-id",
30			},
31			expected: "DocumentRef-a-doc:SPDXRef-some-id",
32		},
33		{
34			name: "DocumentRefID no ElementRefID",
35			value: DocElementID{
36				DocumentRefID: "a-doc",
37			},
38			err: true,
39		},
40		{
41			name: "SpecialID",
42			value: DocElementID{
43				SpecialID: "special-id",
44			},
45			expected: "special-id",
46		},
47	}
48
49	for _, test := range tests {
50		t.Run(test.name, func(t *testing.T) {
51			result, err := json.Marshal(test.value)
52			switch {
53			case !test.err && err != nil:
54				t.Fatalf("unexpected error: %v", err)
55			case test.err && err == nil:
56				t.Fatalf("expected error but got none")
57			case test.err:
58				return
59			}
60			s := string(result)
61			if !strings.HasPrefix(s, `"`) || !strings.HasSuffix(s, `"`) {
62				t.Fatalf("string was not returned: %s", s)
63			}
64			s = strings.Trim(s, `"`)
65			if test.expected != s {
66				t.Fatalf("%s != %s", test.expected, s)
67			}
68		})
69	}
70}
71
72func Test_DocElementIDDecoding(t *testing.T) {
73	tests := []struct {
74		name     string
75		value    string
76		expected DocElementID
77		err      bool
78	}{
79		{
80			name:  "ElementRefID",
81			value: "SPDXRef-some-id",
82			expected: DocElementID{
83				ElementRefID: "some-id",
84			},
85		},
86		{
87			name:  "DocumentRefID:ElementRefID",
88			value: "DocumentRef-a-doc:SPDXRef-some-id",
89			expected: DocElementID{
90				DocumentRefID: "a-doc",
91				ElementRefID:  "some-id",
92			},
93		},
94		{
95			name:  "DocumentRefID no ElementRefID",
96			value: "DocumentRef-a-doc",
97			expected: DocElementID{
98				DocumentRefID: "a-doc",
99			},
100		},
101		{
102			name:  "DocumentRefID invalid ElementRefID",
103			value: "DocumentRef-a-doc:invalid",
104			err:   true,
105		},
106		{
107			name:  "invalid format",
108			value: "some-id-without-spdxref",
109			err:   true,
110		},
111		{
112			name:  "SpecialID NONE",
113			value: "NONE",
114			expected: DocElementID{
115				SpecialID: "NONE",
116			},
117		},
118		{
119			name:  "SpecialID NOASSERTION",
120			value: "NOASSERTION",
121			expected: DocElementID{
122				SpecialID: "NOASSERTION",
123			},
124		},
125	}
126
127	for _, test := range tests {
128		t.Run(test.name, func(t *testing.T) {
129			out := DocElementID{}
130			s := fmt.Sprintf(`"%s"`, test.value)
131			err := json.Unmarshal([]byte(s), &out)
132			switch {
133			case !test.err && err != nil:
134				t.Fatalf("unexpected error: %v", err)
135			case test.err && err == nil:
136				t.Fatalf("expected error but got none")
137			case test.err:
138				return
139			}
140			if !reflect.DeepEqual(test.expected, out) {
141				t.Fatalf("unexpected value: %v != %v", test.expected, out)
142			}
143		})
144	}
145}
146
147func Test_ElementIDEncoding(t *testing.T) {
148	tests := []struct {
149		name     string
150		value    ElementID
151		expected string
152		err      bool
153	}{
154		{
155			name:     "appends spdxref",
156			value:    ElementID("some-id"),
157			expected: "SPDXRef-some-id",
158		},
159		{
160			name:     "appends spdxref",
161			value:    ElementID("SPDXRef-some-id"),
162			expected: "SPDXRef-some-id",
163		},
164	}
165
166	for _, test := range tests {
167		t.Run(test.name, func(t *testing.T) {
168			result, err := json.Marshal(test.value)
169			switch {
170			case !test.err && err != nil:
171				t.Fatalf("unexpected error: %v", err)
172			case test.err && err == nil:
173				t.Fatalf("expected error but got none")
174			case test.err:
175				return
176			}
177			s := string(result)
178			if !strings.HasPrefix(s, `"`) || !strings.HasSuffix(s, `"`) {
179				t.Fatalf("string was not returned: %s", s)
180			}
181			s = strings.Trim(s, `"`)
182			if test.expected != s {
183				t.Fatalf("%s != %s", test.expected, s)
184			}
185		})
186	}
187}
188
189func Test_ElementIDDecoding(t *testing.T) {
190	tests := []struct {
191		name     string
192		value    string
193		expected ElementID
194		err      bool
195	}{
196		{
197			name:     "valid id",
198			value:    "SPDXRef-some-id",
199			expected: ElementID("some-id"),
200		},
201		{
202			name:  "invalid format",
203			value: "some-id-without-spdxref",
204			err:   true,
205		},
206	}
207
208	for _, test := range tests {
209		t.Run(test.name, func(t *testing.T) {
210			var out ElementID
211			s := fmt.Sprintf(`"%s"`, test.value)
212			err := json.Unmarshal([]byte(s), &out)
213			switch {
214			case !test.err && err != nil:
215				t.Fatalf("unexpected error: %v", err)
216			case test.err && err == nil:
217				t.Fatalf("expected error but got none")
218			case test.err:
219				return
220			}
221			if !reflect.DeepEqual(test.expected, out) {
222				t.Fatalf("unexpected value: %v != %v", test.expected, out)
223			}
224		})
225	}
226}
227
228func Test_ElementIDStructEncoding(t *testing.T) {
229	type typ struct {
230		Id ElementID `json:"id"`
231	}
232	tests := []struct {
233		name     string
234		value    typ
235		expected string
236		err      bool
237	}{
238		{
239			name: "appends spdxref",
240			value: typ{
241				Id: ElementID("some-id"),
242			},
243			expected: `{"id":"SPDXRef-some-id"}`,
244		},
245		{
246			name: "appends spdxref",
247			value: typ{
248				Id: ElementID("SPDXRef-some-id"),
249			},
250			expected: `{"id":"SPDXRef-some-id"}`,
251		},
252	}
253
254	for _, test := range tests {
255		t.Run(test.name, func(t *testing.T) {
256			result, err := json.Marshal(test.value)
257			switch {
258			case !test.err && err != nil:
259				t.Fatalf("unexpected error: %v", err)
260			case test.err && err == nil:
261				t.Fatalf("expected error but got none")
262			case test.err:
263				return
264			}
265			s := string(result)
266			if test.expected != s {
267				t.Fatalf("%s != %s", test.expected, s)
268			}
269		})
270	}
271}
272
273func Test_ElementIDStructDecoding(t *testing.T) {
274	type typ struct {
275		Id ElementID `json:"id"`
276	}
277	tests := []struct {
278		name     string
279		value    string
280		expected typ
281		err      bool
282	}{
283		{
284			name: "valid id",
285			expected: typ{
286				Id: ElementID("some-id"),
287			},
288			value: `{"id":"SPDXRef-some-id"}`,
289		},
290		{
291			name:  "invalid format",
292			value: `{"id":"some-id"}`,
293			err:   true,
294		},
295	}
296
297	for _, test := range tests {
298		t.Run(test.name, func(t *testing.T) {
299			out := typ{}
300			err := json.Unmarshal([]byte(test.value), &out)
301			switch {
302			case !test.err && err != nil:
303				t.Fatalf("unexpected error: %v", err)
304			case test.err && err == nil:
305				t.Fatalf("expected error but got none")
306			case test.err:
307				return
308			}
309			if !reflect.DeepEqual(test.expected, out) {
310				t.Fatalf("unexpected value: %v != %v", test.expected, out)
311			}
312		})
313	}
314}
315