From 3d282b296413e92031981be210c8acbafa5ff4d1 Mon Sep 17 00:00:00 2001
From: Rob Fitzpatrick <marcusaureliusalius@gmail.com>
Date: Sat, 17 Oct 2020 20:59:02 +0100
Subject: [PATCH] Adding tolerance in a few tests for existing objects on token

---
 keys_test.go | 57 +++++++++++++++++++++++++++++++++++++++++++---------
 1 file changed, 48 insertions(+), 9 deletions(-)

diff --git a/keys_test.go b/keys_test.go
index ca8ab6a..151ed58 100644
--- a/keys_test.go
+++ b/keys_test.go
@@ -41,10 +41,30 @@ func TestFindKeysRequiresIdOrLabel(t *testing.T) {
 
 func TestFindingKeysWithAttributes(t *testing.T) {
 	withContext(t, func(ctx *Context) {
+
+		var err error
+        // Compensate for unclean starting condition
+		preconditionAttrs_CkaValueLen16 := NewAttributeSet()
+		err = preconditionAttrs_CkaValueLen16.Set(CkaValueLen, 16)
+		require.NoError(t, err)
+
+		var preconditionKeys_CkaValueLen16 []*SecretKey
+		preconditionKeys_CkaValueLen16, err = ctx.FindKeysWithAttributes(preconditionAttrs_CkaValueLen16)
+		require.NoError(t, err)
+
+		preconditionAttrs_CkaValueLen32 := NewAttributeSet()
+		err = preconditionAttrs_CkaValueLen32.Set(CkaValueLen, 32)
+		require.NoError(t, err)
+
+		var preconditionKeys_CkaValueLen32 []*SecretKey
+		preconditionKeys_CkaValueLen32, err = ctx.FindKeysWithAttributes(preconditionAttrs_CkaValueLen32)
+		require.NoError(t, err)
+
 		label := randomBytes()
 		label2 := randomBytes()
 
-		key, err := ctx.GenerateSecretKeyWithLabel(randomBytes(), label, 128, CipherAES)
+		var key *SecretKey
+		key, err = ctx.GenerateSecretKeyWithLabel(randomBytes(), label, 128, CipherAES)
 		require.NoError(t, err)
 		defer func(k *SecretKey) { _ = k.Delete() }(key)
 
@@ -73,7 +93,7 @@ func TestFindingKeysWithAttributes(t *testing.T) {
 
 		keys, err = ctx.FindKeysWithAttributes(attrs)
 		require.NoError(t, err)
-		require.Len(t, keys, 2)
+		require.Len(t, keys, 2 + len(preconditionKeys_CkaValueLen16))
 
 		attrs = NewAttributeSet()
 		err = attrs.Set(CkaValueLen, 32)
@@ -81,13 +101,21 @@ func TestFindingKeysWithAttributes(t *testing.T) {
 
 		keys, err = ctx.FindKeysWithAttributes(attrs)
 		require.NoError(t, err)
-		require.Len(t, keys, 1)
+		require.Len(t, keys, 1 + len(preconditionKeys_CkaValueLen32))
 	})
 }
 
 func TestFindingKeyPairsWithAttributes(t *testing.T) {
 	withContext(t, func(ctx *Context) {
 
+		// Compensate for unclean starting stage
+		var err error
+		preconditionAttrs_CkaType_CKK_RSA := NewAttributeSet()
+		err = preconditionAttrs_CkaType_CKK_RSA.Set(CkaKeyType, pkcs11.CKK_RSA)
+		var preconditionKeysRsa []Signer
+		preconditionKeysRsa, err = ctx.FindKeyPairsWithAttributes(preconditionAttrs_CkaType_CKK_RSA)
+		require.NoError(t, err)
+
 		// Note: we use common labels, not IDs in this test code. AWS CloudHSM
 		// does not accept two keys with the same ID.
 
@@ -121,12 +149,17 @@ func TestFindingKeyPairsWithAttributes(t *testing.T) {
 		_ = attrs.Set(CkaKeyType, pkcs11.CKK_RSA)
 		keys, err = ctx.FindKeyPairsWithAttributes(attrs)
 		require.NoError(t, err)
-		require.Len(t, keys, 3)
+		require.Len(t, keys, 3 + len(preconditionKeysRsa))
 	})
 }
 
 func TestFindingAllKeys(t *testing.T) {
 	withContext(t, func(ctx *Context) {
+
+		var preconditionKeys []*SecretKey
+		var err error
+		preconditionKeys, err = ctx.FindAllKeys()
+
 		for i := 0; i < 10; i++ {
 			id := randomBytes()
 			key, err := ctx.GenerateSecretKey(id, 128, CipherAES)
@@ -134,17 +167,22 @@ func TestFindingAllKeys(t *testing.T) {
 
 			defer func(k *SecretKey) { _ = k.Delete() }(key)
 		}
-
-		keys, err := ctx.FindAllKeys()
+		var keys []*SecretKey
+		keys, err = ctx.FindAllKeys()
 		require.NoError(t, err)
 		require.NotNil(t, keys)
 
-		require.Len(t, keys, 10)
+		require.Len(t, keys, 10 + len(preconditionKeys))
 	})
 }
 
 func TestFindingAllKeyPairs(t *testing.T) {
 	withContext(t, func(ctx *Context) {
+
+		var preconditionRsaKeys []Signer
+		var err error
+		preconditionRsaKeys, err = ctx.FindAllKeyPairs()
+
 		for i := 1; i <= 5; i++ {
 			id := randomBytes()
 			key, err := ctx.GenerateRSAKeyPair(id, rsaSize)
@@ -153,11 +191,12 @@ func TestFindingAllKeyPairs(t *testing.T) {
 			defer func(k Signer) { _ = k.Delete() }(key)
 		}
 
-		keys, err := ctx.FindAllKeyPairs()
+		var keys []Signer
+		keys, err = ctx.FindAllKeyPairs()
 		require.NoError(t, err)
 		require.NotNil(t, keys)
 
-		require.Len(t, keys, 5)
+		require.Len(t, keys, 5 + len(preconditionRsaKeys))
 	})
 }