github.com/xmidt-org/webpa-common@v1.11.9/secure/key/purpose_test.go (about)

     1  package key
     2  
     3  import (
     4  	"encoding/json"
     5  	"github.com/stretchr/testify/assert"
     6  	"testing"
     7  )
     8  
     9  func TestPurposeString(t *testing.T) {
    10  	var testData = []struct {
    11  		purpose        Purpose
    12  		expectedString string
    13  	}{
    14  		{PurposeSign, "sign"},
    15  		{PurposeVerify, "verify"},
    16  		{PurposeEncrypt, "encrypt"},
    17  		{PurposeDecrypt, "decrypt"},
    18  		{Purpose(45), "verify"},
    19  		{Purpose(-1), "verify"},
    20  	}
    21  
    22  	for _, test := range testData {
    23  		actualString := test.purpose.String()
    24  		if actualString != test.expectedString {
    25  			t.Errorf("Expected String() [%s] but got [%s]", test.expectedString, actualString)
    26  		}
    27  	}
    28  }
    29  
    30  func TestPurposeMarshalJSON(t *testing.T) {
    31  	var testData = []struct {
    32  		purpose      Purpose
    33  		expectedJSON string
    34  	}{
    35  		{PurposeSign, `"sign"`},
    36  		{PurposeVerify, `"verify"`},
    37  		{PurposeEncrypt, `"encrypt"`},
    38  		{PurposeDecrypt, `"decrypt"`},
    39  		{Purpose(45), `"verify"`},
    40  		{Purpose(-1), `"verify"`},
    41  	}
    42  
    43  	for _, test := range testData {
    44  		actualJSON, err := json.Marshal(test.purpose)
    45  		if err != nil {
    46  			t.Fatalf("Failed to marshal JSON: %v", err)
    47  		}
    48  
    49  		if string(actualJSON) != test.expectedJSON {
    50  			t.Errorf("Expected JSON [%s] but got [%s]", test.expectedJSON, actualJSON)
    51  		}
    52  	}
    53  }
    54  
    55  func TestPurposeUnmarshalJSON(t *testing.T) {
    56  	var validRecords = []struct {
    57  		JSON            string
    58  		expectedPurpose Purpose
    59  	}{
    60  		{`"sign"`, PurposeSign},
    61  		{`"verify"`, PurposeVerify},
    62  		{`"encrypt"`, PurposeEncrypt},
    63  		{`"decrypt"`, PurposeDecrypt},
    64  	}
    65  
    66  	var invalidRecords = []string{
    67  		"",
    68  		"0",
    69  		"123",
    70  		`""`,
    71  		`"invalid"`,
    72  		`"SIGN"`,
    73  		`"vERifY"`,
    74  	}
    75  
    76  	for _, test := range validRecords {
    77  		var actualPurpose Purpose
    78  		err := json.Unmarshal([]byte(test.JSON), &actualPurpose)
    79  		if err != nil {
    80  			t.Fatalf("Failed to unmarshal JSON: %v", err)
    81  		}
    82  
    83  		if actualPurpose != test.expectedPurpose {
    84  			t.Errorf("Expected purpose [%d] but got [%d]", test.expectedPurpose, actualPurpose)
    85  		}
    86  	}
    87  
    88  	for _, invalidJSON := range invalidRecords {
    89  		var actualPurpose Purpose
    90  		err := json.Unmarshal([]byte(invalidJSON), &actualPurpose)
    91  		if err == nil {
    92  			t.Errorf("Should have failed to marshal JSON [%s]", invalidJSON)
    93  		}
    94  	}
    95  }
    96  
    97  func TestPurposeRequiresPrivateKey(t *testing.T) {
    98  	assert := assert.New(t)
    99  
   100  	var testData = []struct {
   101  		purpose                    Purpose
   102  		expectedRequiresPrivateKey bool
   103  	}{
   104  		{PurposeVerify, false},
   105  		{PurposeSign, true},
   106  		{PurposeEncrypt, true},
   107  		{PurposeDecrypt, false},
   108  	}
   109  
   110  	for _, record := range testData {
   111  		t.Logf("%#v", record)
   112  		assert.Equal(record.expectedRequiresPrivateKey, record.purpose.RequiresPrivateKey())
   113  	}
   114  }