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

     1  package key
     2  
     3  import (
     4  	"encoding/pem"
     5  	"fmt"
     6  	"github.com/stretchr/testify/assert"
     7  	"io/ioutil"
     8  	"testing"
     9  )
    10  
    11  func makeNonKeyPEMBlock() []byte {
    12  	block := pem.Block{
    13  		Type:  "NOT A KEY",
    14  		Bytes: []byte{1, 2, 3, 4, 5},
    15  	}
    16  
    17  	return pem.EncodeToMemory(&block)
    18  }
    19  
    20  func TestDefaultParser(t *testing.T) {
    21  	assert := assert.New(t)
    22  
    23  	var testData = []struct {
    24  		keyFilePath   string
    25  		purpose       Purpose
    26  		expectPrivate bool
    27  	}{
    28  		{publicKeyFilePath, PurposeVerify, false},
    29  		{privateKeyFilePath, PurposeEncrypt, true},
    30  		{privateKeyFilePath, PurposeSign, true},
    31  		{publicKeyFilePath, PurposeDecrypt, false},
    32  	}
    33  
    34  	for _, record := range testData {
    35  		t.Logf("%v", record)
    36  
    37  		data, err := ioutil.ReadFile(record.keyFilePath)
    38  		if !assert.Nil(err) {
    39  			continue
    40  		}
    41  
    42  		pair, err := DefaultParser.ParseKey(record.purpose, data)
    43  		if !assert.Nil(err) && !assert.NotNil(pair) {
    44  			continue
    45  		}
    46  
    47  		assert.NotNil(pair.Public())
    48  		assert.Equal(record.expectPrivate, pair.HasPrivate())
    49  		assert.Equal(record.expectPrivate, pair.Private() != nil)
    50  		assert.Equal(record.purpose, pair.Purpose())
    51  	}
    52  }
    53  
    54  func TestDefaultParserString(t *testing.T) {
    55  	assert := assert.New(t)
    56  	assert.NotEmpty(fmt.Sprintf("%s", DefaultParser))
    57  }
    58  
    59  func TestDefaultParserNoPEM(t *testing.T) {
    60  	assert := assert.New(t)
    61  
    62  	notPEM := []byte{9, 9, 9}
    63  	pair, err := DefaultParser.ParseKey(PurposeVerify, notPEM)
    64  	assert.Nil(pair)
    65  	assert.Equal(ErrorPEMRequired, err)
    66  }
    67  
    68  func TestDefaultParserInvalidPublicKey(t *testing.T) {
    69  	assert := assert.New(t)
    70  
    71  	for _, purpose := range []Purpose{PurposeVerify, PurposeDecrypt} {
    72  		t.Logf("%s", purpose)
    73  		pair, err := DefaultParser.ParseKey(purpose, makeNonKeyPEMBlock())
    74  		assert.Nil(pair)
    75  		assert.NotNil(err)
    76  	}
    77  }
    78  
    79  func TestDefaultParserInvalidPrivateKey(t *testing.T) {
    80  	assert := assert.New(t)
    81  
    82  	for _, purpose := range []Purpose{PurposeSign, PurposeEncrypt} {
    83  		t.Logf("%s", purpose)
    84  		pair, err := DefaultParser.ParseKey(purpose, makeNonKeyPEMBlock())
    85  		assert.Nil(pair)
    86  		assert.Equal(ErrorUnsupportedPrivateKeyFormat, err)
    87  	}
    88  }