Replace packr with stdlib embed

credential/exchange/model_test.go

@@ -1,9 +1,9 @@
 package exchange
 
 import (
+	"embed"
 	"testing"
 
-	"github.com/gobuffalo/packr/v2"
 	"github.com/goccy/go-json"
 	"github.com/stretchr/testify/assert"
 )
@@ -21,7 +21,8 @@ const (
 )
 
 var (
-	peBox = packr.New("Presentation Exchange Test Vectors", "../test_vectors")
+	//go:embed testdata
+	testVectors embed.FS
 )
 
 // Round trip de/serialize to test our object models
@@ -179,5 +180,6 @@ func TestPresentationSubmission(t *testing.T) {
 }
 
 func getTestVector(fileName string) (string, error) {
-	return peBox.FindString(fileName)
+	b, err := testVectors.ReadFile("testdata/" + fileName)
+	return string(b), err
 }

credential/exchange/schema.go

@@ -1,7 +1,6 @@
 package exchange
 
 import (
-	"github.com/gobuffalo/packr/v2"
 	"github.com/goccy/go-json"
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
@@ -18,17 +17,13 @@ const (
 	submissionRequirementsSchema         string = "pe-submission-requirements.json"
 )
 
-var (
-	schemaBox = packr.New("Presentation Exchange JSON Schemas", "../known_schemas")
-)
-
 // IsValidPresentationDefinition validates a given presentation definition object against its known JSON schema
 func IsValidPresentationDefinition(definition PresentationDefinition) error {
 	jsonBytes, err := json.Marshal(definition)
 	if err != nil {
 		return errors.Wrap(err, "could not marshal presentation definition to JSON")
 	}
-	s, err := getKnownSchema(presentationDefinitionSchema)
+	s, err := schema.GetKnownSchema(presentationDefinitionSchema)
 	if err != nil {
 		return errors.Wrap(err, "could not get presentation definition schema")
 	}
@@ -45,7 +40,7 @@ func IsValidPresentationDefinitionEnvelope(definition PresentationDefinitionEnve
 	if err != nil {
 		return errors.Wrap(err, "could not marshal presentation definition to JSON")
 	}
-	s, err := getKnownSchema(presentationDefinitionEnvelopeSchema)
+	s, err := schema.GetKnownSchema(presentationDefinitionEnvelopeSchema)
 	if err != nil {
 		return errors.Wrap(err, "could not get presentation definition schema")
 	}
@@ -67,7 +62,7 @@ func IsValidPresentationSubmission(submission PresentationSubmission) error {
 	if err != nil {
 		return errors.Wrap(err, "could not marshal presentation submission to JSON")
 	}
-	s, err := getKnownSchema(presentationSubmissionSchema)
+	s, err := schema.GetKnownSchema(presentationSubmissionSchema)
 	if err != nil {
 		return errors.Wrap(err, "could not get presentation submission schema")
 	}
@@ -84,7 +79,7 @@ func IsValidFormatDeclaration(format ClaimFormat) error {
 	if err != nil {
 		return errors.Wrap(err, "could not marshal claim format to JSON")
 	}
-	s, err := getKnownSchema(formatDeclarationSchema)
+	s, err := schema.GetKnownSchema(formatDeclarationSchema)
 	if err != nil {
 		return errors.Wrap(err, "could not get claim format schema")
 	}
@@ -101,7 +96,7 @@ func IsValidSubmissionRequirement(requirement SubmissionRequirement) error {
 	if err != nil {
 		return errors.Wrap(err, "could not marshal submission requirement to JSON")
 	}
-	s, err := getKnownSchema(submissionRequirementSchema)
+	s, err := schema.GetKnownSchema(submissionRequirementSchema)
 	if err != nil {
 		return errors.Wrap(err, "could not get submission requirement schema")
 	}
@@ -123,7 +118,7 @@ func AreValidSubmissionRequirements(requirements []SubmissionRequirement) error
 	if err != nil {
 		return errors.Wrap(err, "could not marshal submission requirements to JSON")
 	}
-	s, err := getKnownSchema(submissionRequirementsSchema)
+	s, err := schema.GetKnownSchema(submissionRequirementsSchema)
 	if err != nil {
 		return errors.Wrap(err, "could not get submission requirements schema")
 	}
@@ -133,7 +128,3 @@ func AreValidSubmissionRequirements(requirements []SubmissionRequirement) error
 	}
 	return nil
 }
-
-func getKnownSchema(fileName string) (string, error) {
-	return schemaBox.FindString(fileName)
-}

credential/exchange/schema_test.go

@@ -10,19 +10,19 @@ import (
 
 // Get all schemas, make sure they're valid
 func TestPresentationExchangeSchemas(t *testing.T) {
-	pdSchema, err := getKnownSchema(presentationDefinitionSchema)
+	pdSchema, err := schema.GetKnownSchema(presentationDefinitionSchema)
 	assert.NoError(t, err)
 	assert.NotEmpty(t, pdSchema)
 	err = schema.IsValidJSONSchema(pdSchema)
 	assert.NoError(t, err)
 
-	fdSchema, err := getKnownSchema(formatDeclarationSchema)
+	fdSchema, err := schema.GetKnownSchema(formatDeclarationSchema)
 	assert.NoError(t, err)
 	assert.NotEmpty(t, fdSchema)
 	err = schema.IsValidJSONSchema(fdSchema)
 	assert.NoError(t, err)
 
-	srSchema, err := getKnownSchema(submissionRequirementsSchema)
+	srSchema, err := schema.GetKnownSchema(submissionRequirementsSchema)
 	assert.NoError(t, err)
 	assert.NotEmpty(t, srSchema)
 	err = schema.IsValidJSONSchema(srSchema)

credential/manifest/model_test.go

@@ -1,9 +1,9 @@
 package manifest
 
 import (
+	"embed"
 	"testing"
 
-	"github.com/gobuffalo/packr/v2"
 	"github.com/goccy/go-json"
 	"github.com/stretchr/testify/assert"
 )
@@ -16,7 +16,8 @@ const (
 )
 
 var (
-	manifestBox = packr.New("Credential Manifest Test Vectors", "../test_vectors")
+	//go:embed testdata
+	testVectors embed.FS
 )
 
 // Round trip de/serialize to test our object models, and check validity
@@ -104,5 +105,6 @@ func TestCredentialFulfillment(t *testing.T) {
 }
 
 func getTestVector(fileName string) (string, error) {
-	return manifestBox.FindString(fileName)
+	b, err := testVectors.ReadFile("testdata/" + fileName)
+	return string(b), err
 }

credential/manifest/schema.go

@@ -1,7 +1,6 @@
 package manifest
 
 import (
-	"github.com/gobuffalo/packr/v2"
 	"github.com/goccy/go-json"
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
@@ -16,17 +15,13 @@ const (
 	outputDescriptorsSchema     string = "cm-output-descriptors.json"
 )
 
-var (
-	schemaBox = packr.New("Credential Manifest JSON Schemas", "../known_schemas")
-)
-
 // IsValidCredentialManifest validates a given credential manifest object against its known JSON schema
 func IsValidCredentialManifest(manifest CredentialManifest) error {
 	jsonBytes, err := json.Marshal(manifest)
 	if err != nil {
 		return errors.Wrap(err, "could not marshal manifest to JSON")
 	}
-	s, err := getKnownSchema(credentialManifestSchema)
+	s, err := schema.GetKnownSchema(credentialManifestSchema)
 	if err != nil {
 		return errors.Wrap(err, "could not get credential manifest schema")
 	}
@@ -43,7 +38,7 @@ func IsValidCredentialApplication(application CredentialApplication) error {
 	if err != nil {
 		return errors.Wrap(err, "could not marshal application to JSON")
 	}
-	s, err := getKnownSchema(credentialApplicationSchema)
+	s, err := schema.GetKnownSchema(credentialApplicationSchema)
 	if err != nil {
 		return errors.Wrap(err, "could not get credential application schema")
 	}
@@ -65,7 +60,7 @@ func IsValidCredentialFulfillment(fulfillment CredentialFulfillment) error {
 	if err != nil {
 		return errors.Wrap(err, "could not marshal fulfillment to JSON")
 	}
-	s, err := getKnownSchema(credentialFulfillmentSchema)
+	s, err := schema.GetKnownSchema(credentialFulfillmentSchema)
 	if err != nil {
 		return errors.Wrap(err, "could not get credential fulfillment schema")
 	}
@@ -87,7 +82,7 @@ func AreValidOutputDescriptors(descriptors []OutputDescriptor) error {
 	if err != nil {
 		return errors.Wrap(err, "could not marshal output descriptors to JSON")
 	}
-	s, err := getKnownSchema(outputDescriptorsSchema)
+	s, err := schema.GetKnownSchema(outputDescriptorsSchema)
 	if err != nil {
 		return errors.Wrap(err, "could not get output descriptors schema")
 	}
@@ -97,7 +92,3 @@ func AreValidOutputDescriptors(descriptors []OutputDescriptor) error {
 	}
 	return nil
 }
-
-func getKnownSchema(fileName string) (string, error) {
-	return schemaBox.FindString(fileName)
-}

credential/manifest/schema_test.go

@@ -10,25 +10,25 @@ import (
 
 // Get all schemas, make sure they're valid
 func TestCredentialManifestSchemas(t *testing.T) {
-	cmSchema, err := getKnownSchema(credentialManifestSchema)
+	cmSchema, err := schema.GetKnownSchema(credentialManifestSchema)
 	assert.NoError(t, err)
 	assert.NotEmpty(t, cmSchema)
 	err = schema.IsValidJSONSchema(cmSchema)
 	assert.NoError(t, err)
 
-	caSchema, err := getKnownSchema(credentialApplicationSchema)
+	caSchema, err := schema.GetKnownSchema(credentialApplicationSchema)
 	assert.NoError(t, err)
 	assert.NotEmpty(t, caSchema)
 	err = schema.IsValidJSONSchema(caSchema)
 	assert.NoError(t, err)
 
-	cfSchema, err := getKnownSchema(credentialFulfillmentSchema)
+	cfSchema, err := schema.GetKnownSchema(credentialFulfillmentSchema)
 	assert.NoError(t, err)
 	assert.NotEmpty(t, cfSchema)
 	err = schema.IsValidJSONSchema(cfSchema)
 	assert.NoError(t, err)
 
-	odSchema, err := getKnownSchema(outputDescriptorsSchema)
+	odSchema, err := schema.GetKnownSchema(outputDescriptorsSchema)
 	assert.NoError(t, err)
 	assert.NotEmpty(t, odSchema)
 	err = schema.IsValidJSONSchema(odSchema)

credential/model_test.go

@@ -1,11 +1,11 @@
 package credential
 
 import (
+	"embed"
 	"testing"
 
 	"github.com/goccy/go-json"
 
-	"github.com/gobuffalo/packr/v2"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -21,12 +21,12 @@ const (
 )
 
 var (
-	box           = packr.New("VC & VP Test Vectors", "/test_vectors")
+	//go:embed testdata
+	testVectors   embed.FS
 	vcTestVectors = []string{VCTestVector1, VCTestVector2, VCTestVector3, VCTestVector4}
 	vpTestVectors = []string{VPTestVector1, VPTestVector2}
 )
 
-// Before running, you'll need to execute `mage packr`
 func TestVCVectors(t *testing.T) {
 	// round trip serialize and de-serialize from json to our object model
 	for _, tv := range vcTestVectors {
@@ -46,7 +46,6 @@ func TestVCVectors(t *testing.T) {
 	}
 }
 
-// Before running, you'll need to execute `mage packr`
 func TestVPVectors(t *testing.T) {
 	// round trip serialize and de-serialize from json to our object model
 	for _, tv := range vpTestVectors {
@@ -67,5 +66,6 @@ func TestVPVectors(t *testing.T) {
 }
 
 func getTestVector(fileName string) (string, error) {
-	return box.FindString(fileName)
+	b, err := testVectors.ReadFile("testdata/" + fileName)
+	return string(b), err
 }

credential/rendering/model_test.go

@@ -1,9 +1,9 @@
 package rendering
 
 import (
+	"embed"
 	"testing"
 
-	"github.com/gobuffalo/packr/v2"
 	"github.com/goccy/go-json"
 	"github.com/stretchr/testify/assert"
 )
@@ -17,7 +17,8 @@ const (
 )
 
 var (
-	wrBox = packr.New("Wallet Rendering Test Vectors", "../test_vectors")
+	//go:embed testdata
+	testVectors embed.FS
 )
 
 func TestEntityStyleDescriptor(t *testing.T) {
@@ -103,5 +104,6 @@ func TestLabeledDisplayMappingObject(t *testing.T) {
 }
 
 func getTestVector(fileName string) (string, error) {
-	return wrBox.FindString(fileName)
+	b, err := testVectors.ReadFile("testdata/" + fileName)
+	return string(b), err
 }

credential/rendering/schema.go

@@ -1,7 +1,6 @@
 package rendering
 
 import (
-	"github.com/gobuffalo/packr/v2"
 	"github.com/goccy/go-json"
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
@@ -15,17 +14,13 @@ const (
 	labeledDisplayMappingObjectSchema string = "wr-labeled-display-mapping-object.json"
 )
 
-var (
-	schemaBox = packr.New("Wallet Rendering JSON Schemas", "../known_schemas")
-)
-
 // IsValidEntityStyle validates an entity style descriptor against its known schema
 func IsValidEntityStyle(esd EntityStyleDescriptor) error {
 	jsonBytes, err := json.Marshal(esd)
 	if err != nil {
 		return errors.Wrap(err, "could not marshal entity style descriptor")
 	}
-	s, err := getKnownSchema(entityStylesSchema)
+	s, err := schema.GetKnownSchema(entityStylesSchema)
 	if err != nil {
 		return errors.Wrap(err, "could not get entity styles schema")
 	}
@@ -42,7 +37,7 @@ func IsValidDisplayMappingObject(dmo DisplayMappingObject) error {
 	if err != nil {
 		return errors.Wrap(err, "could not marshal display mapping object")
 	}
-	s, err := getKnownSchema(displayMappingObjectSchema)
+	s, err := schema.GetKnownSchema(displayMappingObjectSchema)
 	if err != nil {
 		return errors.Wrap(err, "could not get display mapping object schema")
 	}
@@ -59,7 +54,7 @@ func IsValidLabeledDisplayMappingObject(ldmo LabeledDisplayMappingObject) error
 	if err != nil {
 		return errors.Wrap(err, "could not marshal labeled display mapping object")
 	}
-	s, err := getKnownSchema(labeledDisplayMappingObjectSchema)
+	s, err := schema.GetKnownSchema(labeledDisplayMappingObjectSchema)
 	if err != nil {
 		return errors.Wrap(err, "could not get labeled display mapping object schema")
 	}
@@ -69,7 +64,3 @@ func IsValidLabeledDisplayMappingObject(ldmo LabeledDisplayMappingObject) error
 	}
 	return nil
 }
-
-func getKnownSchema(fileName string) (string, error) {
-	return schemaBox.FindString(fileName)
-}