session_test.go 17.3 KB
Newer Older
1
package sessiontest
Sietse Ringers's avatar
Sietse Ringers committed
2
3
4

import (
	"encoding/json"
5
6
	"io/ioutil"
	"path/filepath"
Sietse Ringers's avatar
Sietse Ringers committed
7
	"strings"
Sietse Ringers's avatar
Sietse Ringers committed
8
	"testing"
9
	"time"
Sietse Ringers's avatar
Sietse Ringers committed
10

11
	"github.com/dgrijalva/jwt-go"
12
	"github.com/privacybydesign/irmago"
13
	"github.com/privacybydesign/irmago/internal/fs"
14
	"github.com/privacybydesign/irmago/internal/test"
15
	"github.com/privacybydesign/irmago/irmaclient"
Sietse Ringers's avatar
Sietse Ringers committed
16
17
18
	"github.com/stretchr/testify/require"
)

19
20
21
22
func init() {
	irma.ForceHttps = false
}

Sietse Ringers's avatar
Sietse Ringers committed
23
24
25
func getDisclosureRequest(id irma.AttributeTypeIdentifier) *irma.DisclosureRequest {
	return &irma.DisclosureRequest{
		BaseRequest: irma.BaseRequest{Type: irma.ActionDisclosing},
26
		Content: irma.AttributeDisjunctionList([]*irma.AttributeDisjunction{{
Sietse Ringers's avatar
Sietse Ringers committed
27
			Label:      "foo",
28
			Attributes: []irma.AttributeTypeIdentifier{id},
Sietse Ringers's avatar
Sietse Ringers committed
29
		}}),
Sietse Ringers's avatar
Sietse Ringers committed
30
	}
Sietse Ringers's avatar
Sietse Ringers committed
31
32
}

Sietse Ringers's avatar
Sietse Ringers committed
33
34
func getSigningRequest(id irma.AttributeTypeIdentifier) *irma.SignatureRequest {
	return &irma.SignatureRequest{
35
		Message: "test",
36
		DisclosureRequest: irma.DisclosureRequest{
Sietse Ringers's avatar
Sietse Ringers committed
37
			BaseRequest: irma.BaseRequest{Type: irma.ActionSigning},
38
			Content: irma.AttributeDisjunctionList([]*irma.AttributeDisjunction{{
Sietse Ringers's avatar
Sietse Ringers committed
39
				Label:      "foo",
40
				Attributes: []irma.AttributeTypeIdentifier{id},
Sietse Ringers's avatar
Sietse Ringers committed
41
42
			}}),
		},
Sietse Ringers's avatar
Sietse Ringers committed
43
	}
Sietse Ringers's avatar
Sietse Ringers committed
44
45
}

46
func getIssuanceRequest(defaultValidity bool) *irma.IssuanceRequest {
47
	temp := irma.Timestamp(irma.FloorToEpochBoundary(time.Now().AddDate(1, 0, 0)))
48
	var expiry *irma.Timestamp
49

50
51
52
53
	if !defaultValidity {
		expiry = &temp
	}

54
	return &irma.IssuanceRequest{
Sietse Ringers's avatar
Sietse Ringers committed
55
		BaseRequest: irma.BaseRequest{Type: irma.ActionIssuing},
56
		Credentials: []*irma.CredentialRequest{
Sietse Ringers's avatar
Sietse Ringers committed
57
			{
58
				Validity:         expiry,
59
				CredentialTypeID: irma.NewCredentialTypeIdentifier("irma-demo.RU.studentCard"),
Sietse Ringers's avatar
Sietse Ringers committed
60
61
				Attributes: map[string]string{
					"university":        "Radboud",
62
					"studentCardNumber": "31415927",
Sietse Ringers's avatar
Sietse Ringers committed
63
64
65
66
					"studentID":         "s1234567",
					"level":             "42",
				},
			}, {
67
				Validity:         expiry,
68
				CredentialTypeID: irma.NewCredentialTypeIdentifier("irma-demo.MijnOverheid.root"),
Sietse Ringers's avatar
Sietse Ringers committed
69
70
71
72
73
				Attributes: map[string]string{
					"BSN": "299792458",
				},
			},
		},
74
75
76
	}
}

77
78
func getNameIssuanceRequest() *irma.IssuanceRequest {
	expiry := irma.Timestamp(irma.NewMetadataAttribute(0).Expiry())
79
80

	req := &irma.IssuanceRequest{
Sietse Ringers's avatar
Sietse Ringers committed
81
		BaseRequest: irma.BaseRequest{Type: irma.ActionIssuing},
82
83
84
		Credentials: []*irma.CredentialRequest{
			{
				Validity:         &expiry,
85
				CredentialTypeID: irma.NewCredentialTypeIdentifier("irma-demo.MijnOverheid.fullName"),
86
87
88
89
90
91
92
93
94
95
96
97
				Attributes: map[string]string{
					"firstnames": "Johan Pieter",
					"firstname":  "Johan",
					"familyname": "Stuivezand",
				},
			},
		},
	}

	return req
}

Sietse Ringers's avatar
Sietse Ringers committed
98
99
100
101
func getSpecialIssuanceRequest(defaultValidity bool, attribute string) *irma.IssuanceRequest {
	request := getIssuanceRequest(defaultValidity)
	request.Credentials[0].Attributes["studentCardNumber"] = attribute
	return request
102
103
}

Sietse Ringers's avatar
Sietse Ringers committed
104
105
106
func getCombinedIssuanceRequest(id irma.AttributeTypeIdentifier) *irma.IssuanceRequest {
	request := getIssuanceRequest(false)
	request.Disclose = irma.AttributeDisjunctionList{
107
108
		&irma.AttributeDisjunction{Label: "foo", Attributes: []irma.AttributeTypeIdentifier{id}},
	}
Sietse Ringers's avatar
Sietse Ringers committed
109
	return request
Sietse Ringers's avatar
Sietse Ringers committed
110
111
}

Sietse Ringers's avatar
Sietse Ringers committed
112
var TestType = "irmaserver-jwt"
113
114
115
116
117
118
119
120
121
122
123
124
125
126

func startSession(t *testing.T, request irma.SessionRequest, sessiontype string) (*irma.Qr, string) {
	var qr irma.Qr
	var err error
	var token string

	switch TestType {
	case "apiserver":
		url := "http://localhost:8088/irma_api_server/api/v2/" + sessiontype
		err = irma.NewHTTPTransport(url).Post("", &qr, getJwt(t, request, sessiontype, false))
		token = qr.URL
		qr.URL = url + "/" + qr.URL
	case "irmaserver-jwt":
		url := "http://localhost:48682"
127
		err = irma.NewHTTPTransport(url).Post("session", &qr, getJwt(t, request, sessiontype, true))
Sietse Ringers's avatar
Sietse Ringers committed
128
		token = tokenFromURL(qr.URL)
129
130
	case "irmaserver":
		url := "http://localhost:48682"
131
		err = irma.NewHTTPTransport(url).Post("session", &qr, request)
Sietse Ringers's avatar
Sietse Ringers committed
132
		token = tokenFromURL(qr.URL)
133
134
135
136
137
138
139
140
	default:
		t.Fatal("Invalid TestType")
	}

	require.NoError(t, err)
	return &qr, token
}

Sietse Ringers's avatar
Sietse Ringers committed
141
142
143
144
145
146
147
148
func tokenFromURL(url string) string {
	parts := strings.Split(url, "/")
	if len(parts) == 0 {
		return ""
	}
	return parts[len(parts)-1]
}

149
func getJwt(t *testing.T, request irma.SessionRequest, sessiontype string, signed bool) string {
150
	var jwtcontents irma.RequestorJwt
151
152
	var kid string
	switch sessiontype {
Sietse Ringers's avatar
Sietse Ringers committed
153
	case "issue":
154
		kid = "testip"
Sietse Ringers's avatar
Sietse Ringers committed
155
156
		jwtcontents = irma.NewIdentityProviderJwt("testip", request.(*irma.IssuanceRequest))
	case "verification":
157
		kid = "testsp"
Sietse Ringers's avatar
Sietse Ringers committed
158
159
		jwtcontents = irma.NewServiceProviderJwt("testsp", request.(*irma.DisclosureRequest))
	case "signature":
160
		kid = "testsigclient"
Sietse Ringers's avatar
Sietse Ringers committed
161
		jwtcontents = irma.NewSignatureRequestorJwt("testsigclient", request.(*irma.SignatureRequest))
162
163
	}

164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
	var j string
	var err error
	if signed {
		skbts, err := ioutil.ReadFile(filepath.Join(test.FindTestdataFolder(t), "jwtkeys", "requestor1-sk.pem"))
		require.NoError(t, err)
		sk, err := jwt.ParseRSAPrivateKeyFromPEM(skbts)
		require.NoError(t, err)
		tok := jwt.NewWithClaims(jwt.SigningMethodRS256, jwtcontents)
		tok.Header["kid"] = "requestor1"
		j, err = tok.SignedString(sk)
	} else {
		tok := jwt.NewWithClaims(jwt.SigningMethodNone, jwtcontents)
		tok.Header["kid"] = kid
		j, err = tok.SignedString(jwt.UnsafeAllowNoneSignatureType)
	}
179
180
	require.NoError(t, err)

181
	return j
Sietse Ringers's avatar
Sietse Ringers committed
182
183
}

184
func sessionHelper(t *testing.T, request irma.SessionRequest, sessiontype string, client *irmaclient.Client) {
Sietse Ringers's avatar
Sietse Ringers committed
185
186
187
188
189
	if client == nil {
		client = parseStorage(t)
		defer test.ClearTestStorage(t)
	}

Sietse Ringers's avatar
Sietse Ringers committed
190
191
192
193
194
	if TestType == "irmaserver" || TestType == "irmaserver-jwt" {
		StartIrmaServer(JwtServerConfiguration)
		defer StopIrmaServer()
	}

195
	qr, _ := startSession(t, request, sessiontype)
196
197
198

	c := make(chan *SessionResult)
	h := TestHandler{t, c, client}
199
	qrjson, err := json.Marshal(qr)
200
	require.NoError(t, err)
201
	client.NewSession(string(qrjson), h)
202
203
204
205
206
207

	if result := <-c; result != nil {
		require.NoError(t, result.Err)
	}
}

208
func keyshareSessions(t *testing.T, client *irmaclient.Client) {
209
210
	id := irma.NewAttributeTypeIdentifier("irma-demo.RU.studentCard.studentID")
	expiry := irma.Timestamp(irma.NewMetadataAttribute(0).Expiry())
Sietse Ringers's avatar
Sietse Ringers committed
211
212
	issuanceRequest := getCombinedIssuanceRequest(id)
	issuanceRequest.Credentials = append(issuanceRequest.Credentials,
213
214
		&irma.CredentialRequest{
			Validity:         &expiry,
215
			CredentialTypeID: irma.NewCredentialTypeIdentifier("test.test.mijnirma"),
216
217
218
			Attributes:       map[string]string{"email": "testusername"},
		},
	)
Sietse Ringers's avatar
Sietse Ringers committed
219
	sessionHelper(t, issuanceRequest, "issue", client)
220

Sietse Ringers's avatar
Sietse Ringers committed
221
222
	disclosureRequest := getDisclosureRequest(id)
	disclosureRequest.Content = append(disclosureRequest.Content,
223
224
225
226
227
		&irma.AttributeDisjunction{
			Label:      "foo",
			Attributes: []irma.AttributeTypeIdentifier{irma.NewAttributeTypeIdentifier("test.test.mijnirma.email")},
		},
	)
Sietse Ringers's avatar
Sietse Ringers committed
228
	sessionHelper(t, disclosureRequest, "verification", client)
229

Sietse Ringers's avatar
Sietse Ringers committed
230
231
	sigRequest := getSigningRequest(id)
	sigRequest.Content = append(sigRequest.Content,
232
233
234
235
236
		&irma.AttributeDisjunction{
			Label:      "foo",
			Attributes: []irma.AttributeTypeIdentifier{irma.NewAttributeTypeIdentifier("test.test.mijnirma.email")},
		},
	)
Sietse Ringers's avatar
Sietse Ringers committed
237
	sessionHelper(t, sigRequest, "signature", client)
238
239
}

Sietse Ringers's avatar
Sietse Ringers committed
240
func TestSigningSession(t *testing.T) {
241
	id := irma.NewAttributeTypeIdentifier("irma-demo.RU.studentCard.studentID")
Sietse Ringers's avatar
Sietse Ringers committed
242
243
	request := getSigningRequest(id)
	sessionHelper(t, request, "signature", nil)
Sietse Ringers's avatar
Sietse Ringers committed
244
245
246
}

func TestDisclosureSession(t *testing.T) {
247
	id := irma.NewAttributeTypeIdentifier("irma-demo.RU.studentCard.studentID")
Sietse Ringers's avatar
Sietse Ringers committed
248
249
	request := getDisclosureRequest(id)
	sessionHelper(t, request, "verification", nil)
Sietse Ringers's avatar
Sietse Ringers committed
250
251
}

252
253
func TestNoAttributeDisclosureSession(t *testing.T) {
	id := irma.NewAttributeTypeIdentifier("irma-demo.RU.studentCard")
Sietse Ringers's avatar
Sietse Ringers committed
254
255
	request := getDisclosureRequest(id)
	sessionHelper(t, request, "verification", nil)
256
257
}

Sietse Ringers's avatar
Sietse Ringers committed
258
func TestIssuanceSession(t *testing.T) {
259
	id := irma.NewAttributeTypeIdentifier("irma-demo.RU.studentCard.studentID")
Sietse Ringers's avatar
Sietse Ringers committed
260
261
	request := getCombinedIssuanceRequest(id)
	sessionHelper(t, request, "issue", nil)
Sietse Ringers's avatar
Sietse Ringers committed
262
263
}

264
265
func TestDefaultCredentialValidity(t *testing.T) {
	client := parseStorage(t)
Sietse Ringers's avatar
Sietse Ringers committed
266
267
	request := getIssuanceRequest(true)
	sessionHelper(t, request, "issue", client)
268
269
}

270
func TestIssuanceOptionalEmptyAttributes(t *testing.T) {
271
	req := getNameIssuanceRequest()
Sietse Ringers's avatar
Sietse Ringers committed
272
	sessionHelper(t, req, "issue", nil)
273
274
275
276
277
}

func TestIssuanceOptionalZeroLengthAttributes(t *testing.T) {
	req := getNameIssuanceRequest()
	req.Credentials[0].Attributes["prefix"] = ""
Sietse Ringers's avatar
Sietse Ringers committed
278
	sessionHelper(t, req, "issue", nil)
279
280
281
}

func TestIssuanceOptionalSetAttributes(t *testing.T) {
282
283
	req := getNameIssuanceRequest()
	req.Credentials[0].Attributes["prefix"] = "van"
Sietse Ringers's avatar
Sietse Ringers committed
284
	sessionHelper(t, req, "issue", nil)
285
286
}

287
288
func TestLargeAttribute(t *testing.T) {
	client := parseStorage(t)
289
290
	defer test.ClearTestStorage(t)

291
292
	require.NoError(t, client.RemoveAllCredentials())

Sietse Ringers's avatar
Sietse Ringers committed
293
294
	issuanceRequest := getSpecialIssuanceRequest(false, "1234567890123456789012345678901234567890") // 40 chars
	sessionHelper(t, issuanceRequest, "issue", client)
295

Sietse Ringers's avatar
Sietse Ringers committed
296
297
	disclosureRequest := getDisclosureRequest(irma.NewAttributeTypeIdentifier("irma-demo.RU.studentCard.university"))
	sessionHelper(t, disclosureRequest, "verification", client)
298
299
}

300
301
func TestIssuanceSingletonCredential(t *testing.T) {
	client := parseStorage(t)
302
303
	defer test.ClearTestStorage(t)

Sietse Ringers's avatar
Sietse Ringers committed
304
	request := getIssuanceRequest(true)
305
306
	credid := irma.NewCredentialTypeIdentifier("irma-demo.MijnOverheid.root")

307
	require.Nil(t, client.Attributes(credid, 0))
308

Sietse Ringers's avatar
Sietse Ringers committed
309
	sessionHelper(t, request, "issue", client)
310
311
	require.NotNil(t, client.Attributes(credid, 0))
	require.Nil(t, client.Attributes(credid, 1))
312

Sietse Ringers's avatar
Sietse Ringers committed
313
	sessionHelper(t, request, "issue", client)
314
315
	require.NotNil(t, client.Attributes(credid, 0))
	require.Nil(t, client.Attributes(credid, 1))
316
317
}

318
319
320
321
322
323
324
325
/* There is an annoying difference between how Java and Go convert big integers to and from
byte arrays: in Java the sign of the integer is taken into account, but not in Go. This means
that in Java, when converting a bigint to or from a byte array, the most significant bit
indicates the sign of the integer. In Go this is not the case. This resulted in invalid
signatures being issued in the issuance protocol in two distinct ways, of which we test here
that they have been fixed. */
func TestAttributeByteEncoding(t *testing.T) {
	client := parseStorage(t)
326
	defer test.ClearTestStorage(t)
327
328
329
330
331
332
333
	require.NoError(t, client.RemoveAllCredentials())

	/* After bitshifting the presence bit into the large attribute below, the most significant
	bit is 1. In the bigint->[]byte conversion that happens before hashing this attribute, in
	Java this results in an extra 0 byte being prepended in order to have a 0 instead as most
	significant (sign) bit. We test that the Java implementation correctly removes the extraneous
	0 byte. */
Sietse Ringers's avatar
Sietse Ringers committed
334
335
	request := getSpecialIssuanceRequest(false, "a23456789012345678901234567890")
	sessionHelper(t, request, "issue", client)
336
337
338
339
340
341
342

	/* After converting the attribute below to bytes (using UTF8, on which Java and Go do agree),
	the most significant bit of the byte version of this attribute is 1. In the []byte->bigint
	conversion that happens at that point in the Java implementation (bitshifting is done
	afterwards), this results in a negative number in Java and a positive number in Go. We test
	here that the Java correctly prepends a 0 byte just before this conversion in order to get
	the same positive bigint. */
Sietse Ringers's avatar
Sietse Ringers committed
343
344
	request = getSpecialIssuanceRequest(false, "é")
	sessionHelper(t, request, "issue", client)
345
346
}

347
// Use the existing keyshare enrollment and credentials
Sietse Ringers's avatar
Sietse Ringers committed
348
349
350
351
// in a keyshare session of each session type.
// Use keyshareuser.sql to enroll the user at the keyshare server.
func TestKeyshareSessions(t *testing.T) {
	client := parseStorage(t)
352
	defer test.ClearTestStorage(t)
Sietse Ringers's avatar
Sietse Ringers committed
353

354
	keyshareSessions(t, client)
Sietse Ringers's avatar
Sietse Ringers committed
355
}
356
357
358

func TestDisclosureNewAttributeUpdateSchemeManager(t *testing.T) {
	client := parseStorage(t)
359
	defer test.ClearTestStorage(t)
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383

	schemeid := irma.NewSchemeManagerIdentifier("irma-demo")
	credid := irma.NewCredentialTypeIdentifier("irma-demo.RU.studentCard")
	attrid := irma.NewAttributeTypeIdentifier("irma-demo.RU.studentCard.newAttribute")
	require.False(t, client.Configuration.CredentialTypes[credid].ContainsAttribute(attrid))

	client.Configuration.SchemeManagers[schemeid].URL = "http://localhost:48681/irma_configuration_updated/irma-demo"
	disclosureRequest := irma.DisclosureRequest{
		Content: irma.AttributeDisjunctionList{
			&irma.AttributeDisjunction{
				Label: "foo",
				Attributes: []irma.AttributeTypeIdentifier{
					attrid,
				},
			},
		},
	}

	client.Configuration.Download(&disclosureRequest)
	require.True(t, client.Configuration.CredentialTypes[credid].ContainsAttribute(attrid))
}

func TestIssueNewAttributeUpdateSchemeManager(t *testing.T) {
	client := parseStorage(t)
384
385
	defer test.ClearTestStorage(t)

386
387
388
389
390
391
392
393
394
395
396
397
398
399
	schemeid := irma.NewSchemeManagerIdentifier("irma-demo")
	credid := irma.NewCredentialTypeIdentifier("irma-demo.RU.studentCard")
	attrid := irma.NewAttributeTypeIdentifier("irma-demo.RU.studentCard.newAttribute")
	require.False(t, client.Configuration.CredentialTypes[credid].ContainsAttribute(attrid))

	client.Configuration.SchemeManagers[schemeid].URL = "http://localhost:48681/irma_configuration_updated/irma-demo"
	issuanceRequest := getIssuanceRequest(true)
	issuanceRequest.Credentials[0].Attributes["newAttribute"] = "foobar"
	client.Configuration.Download(issuanceRequest)
	require.True(t, client.Configuration.CredentialTypes[credid].ContainsAttribute(attrid))
}

func TestIssueOptionalAttributeUpdateSchemeManager(t *testing.T) {
	client := parseStorage(t)
400
401
	defer test.ClearTestStorage(t)

402
403
404
405
406
407
408
409
410
411
412
413
	schemeid := irma.NewSchemeManagerIdentifier("irma-demo")
	credid := irma.NewCredentialTypeIdentifier("irma-demo.RU.studentCard")
	attrid := irma.NewAttributeTypeIdentifier("irma-demo.RU.studentCard.level")
	require.False(t, client.Configuration.CredentialTypes[credid].AttributeType(attrid).IsOptional())

	client.Configuration.SchemeManagers[schemeid].URL = "http://localhost:48681/irma_configuration_updated/irma-demo"
	issuanceRequest := getIssuanceRequest(true)
	delete(issuanceRequest.Credentials[0].Attributes, "level")
	client.Configuration.Download(issuanceRequest)
	require.True(t, client.Configuration.CredentialTypes[credid].AttributeType(attrid).IsOptional())
}

Sietse Ringers's avatar
Sietse Ringers committed
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
func TestIssueNewCredTypeUpdateSchemeManager(t *testing.T) {
	client := parseStorage(t)
	schemeid := irma.NewSchemeManagerIdentifier("irma-demo")
	credid := irma.NewCredentialTypeIdentifier("irma-demo.RU.studentCard")

	delete(client.Configuration.CredentialTypes, credid)
	require.NotContains(t, client.Configuration.CredentialTypes, credid)

	client.Configuration.SchemeManagers[schemeid].URL = "http://localhost:48681/irma_configuration_updated/irma-demo"
	request := getIssuanceRequest(true)
	client.Configuration.Download(request)

	require.Contains(t, client.Configuration.CredentialTypes, credid)

	test.ClearTestStorage(t)
}

func TestDisclosureNewCredTypeUpdateSchemeManager(t *testing.T) {
	client := parseStorage(t)
	schemeid := irma.NewSchemeManagerIdentifier("irma-demo")
	credid := irma.NewCredentialTypeIdentifier("irma-demo.RU.studentCard")
	attrid := irma.NewAttributeTypeIdentifier("irma-demo.RU.studentCard.level")

	delete(client.Configuration.CredentialTypes, credid)
	require.NotContains(t, client.Configuration.CredentialTypes, credid)

	client.Configuration.SchemeManagers[schemeid].URL = "http://localhost:48681/irma_configuration_updated/irma-demo"
	request := &irma.DisclosureRequest{
		Content: irma.AttributeDisjunctionList([]*irma.AttributeDisjunction{{
			Label:      "foo",
			Attributes: []irma.AttributeTypeIdentifier{attrid},
		}}),
	}
	client.Configuration.Download(request)

	require.Contains(t, client.Configuration.CredentialTypes, credid)

	test.ClearTestStorage(t)
}

454
455
456
457
458
// Test installing a new scheme manager from a qr, and do a(n issuance) session
// within this manager to test the autmatic downloading of credential definitions,
// issuers, and public keys.
func TestDownloadSchemeManager(t *testing.T) {
	client := parseStorage(t)
459
	defer test.ClearTestStorage(t)
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480

	// Remove irma-demo scheme manager as we need to test adding it
	irmademo := irma.NewSchemeManagerIdentifier("irma-demo")
	require.Contains(t, client.Configuration.SchemeManagers, irmademo)
	require.NoError(t, client.Configuration.RemoveSchemeManager(irmademo, true))
	require.NotContains(t, client.Configuration.SchemeManagers, irmademo)

	// Do an add-scheme-manager-session
	c := make(chan *SessionResult)
	qr, err := json.Marshal(&irma.SchemeManagerRequest{
		Type: irma.ActionSchemeManager,
		URL:  "http://localhost:48681/irma_configuration/irma-demo",
	})
	require.NoError(t, err)
	client.NewSession(string(qr), TestHandler{t, c, client})
	if result := <-c; result != nil {
		require.NoError(t, result.Err)
	}
	require.Contains(t, client.Configuration.SchemeManagers, irmademo)

	// Do a session to test downloading of cred types, issuers and keys
Sietse Ringers's avatar
Sietse Ringers committed
481
482
	request := getCombinedIssuanceRequest(irma.NewAttributeTypeIdentifier("irma-demo.RU.studentCard.studentID"))
	sessionHelper(t, request, "issue", client)
483
484
485
486
487

	require.Contains(t, client.Configuration.SchemeManagers, irmademo)
	require.Contains(t, client.Configuration.Issuers, irma.NewIssuerIdentifier("irma-demo.RU"))
	require.Contains(t, client.Configuration.CredentialTypes, irma.NewCredentialTypeIdentifier("irma-demo.RU.studentCard"))

488
	basepath := test.FindTestdataFolder(t) + "/storage/test/irma_configuration/irma-demo"
489
490
491
492
493
494
495
496
497
498
	exists, err := fs.PathExists(basepath + "/description.xml")
	require.NoError(t, err)
	require.True(t, exists)
	exists, err = fs.PathExists(basepath + "/RU/description.xml")
	require.NoError(t, err)
	require.True(t, exists)
	exists, err = fs.PathExists(basepath + "/RU/Issues/studentCard/description.xml")
	require.NoError(t, err)
	require.True(t, exists)
}