keyring_test.go

Documentation: golang.org/x/crypto/ssh/agent

     1  // Copyright 2015 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package agent
     6  
     7  import "testing"
     8  
     9  func addTestKey(t *testing.T, a Agent, keyName string) {
    10  	err := a.Add(AddedKey{
    11  		PrivateKey: testPrivateKeys[keyName],
    12  		Comment:    keyName,
    13  	})
    14  	if err != nil {
    15  		t.Fatalf("failed to add key %q: %v", keyName, err)
    16  	}
    17  }
    18  
    19  func removeTestKey(t *testing.T, a Agent, keyName string) {
    20  	err := a.Remove(testPublicKeys[keyName])
    21  	if err != nil {
    22  		t.Fatalf("failed to remove key %q: %v", keyName, err)
    23  	}
    24  }
    25  
    26  func validateListedKeys(t *testing.T, a Agent, expectedKeys []string) {
    27  	listedKeys, err := a.List()
    28  	if err != nil {
    29  		t.Fatalf("failed to list keys: %v", err)
    30  		return
    31  	}
    32  	if len(listedKeys) != len(expectedKeys) {
    33  		t.Fatalf("expeted %d key, got %d", len(expectedKeys), len(listedKeys))
    34  		return
    35  	}
    36  	actualKeys := make(map[string]bool)
    37  	for _, key := range listedKeys {
    38  		actualKeys[key.Comment] = true
    39  	}
    40  
    41  	matchedKeys := make(map[string]bool)
    42  	for _, expectedKey := range expectedKeys {
    43  		if !actualKeys[expectedKey] {
    44  			t.Fatalf("expected key %q, but was not found", expectedKey)
    45  		} else {
    46  			matchedKeys[expectedKey] = true
    47  		}
    48  	}
    49  
    50  	for actualKey := range actualKeys {
    51  		if !matchedKeys[actualKey] {
    52  			t.Fatalf("key %q was found, but was not expected", actualKey)
    53  		}
    54  	}
    55  }
    56  
    57  func TestKeyringAddingAndRemoving(t *testing.T) {
    58  	keyNames := []string{"dsa", "ecdsa", "rsa", "user"}
    59  
    60  	// add all test private keys
    61  	k := NewKeyring()
    62  	for _, keyName := range keyNames {
    63  		addTestKey(t, k, keyName)
    64  	}
    65  	validateListedKeys(t, k, keyNames)
    66  
    67  	// remove a key in the middle
    68  	keyToRemove := keyNames[1]
    69  	keyNames = append(keyNames[:1], keyNames[2:]...)
    70  
    71  	removeTestKey(t, k, keyToRemove)
    72  	validateListedKeys(t, k, keyNames)
    73  
    74  	// remove all keys
    75  	err := k.RemoveAll()
    76  	if err != nil {
    77  		t.Fatalf("failed to remove all keys: %v", err)
    78  	}
    79  	validateListedKeys(t, k, []string{})
    80  }
    81  
    82  func TestAddDuplicateKey(t *testing.T) {
    83  	keyNames := []string{"rsa", "user"}
    84  
    85  	k := NewKeyring()
    86  	for _, keyName := range keyNames {
    87  		addTestKey(t, k, keyName)
    88  	}
    89  	validateListedKeys(t, k, keyNames)
    90  	// Add the keys again.
    91  	for _, keyName := range keyNames {
    92  		addTestKey(t, k, keyName)
    93  	}
    94  	validateListedKeys(t, k, keyNames)
    95  	// Add an existing key with an updated comment.
    96  	keyName := keyNames[0]
    97  	addedKey := AddedKey{
    98  		PrivateKey: testPrivateKeys[keyName],
    99  		Comment:    "comment updated",
   100  	}
   101  	err := k.Add(addedKey)
   102  	if err != nil {
   103  		t.Fatalf("failed to add key %q: %v", keyName, err)
   104  	}
   105  	// Check the that key is found and the comment was updated.
   106  	keys, err := k.List()
   107  	if err != nil {
   108  		t.Fatalf("failed to list keys: %v", err)
   109  	}
   110  	if len(keys) != len(keyNames) {
   111  		t.Fatalf("expected %d keys, got %d", len(keyNames), len(keys))
   112  	}
   113  	isFound := false
   114  	for _, key := range keys {
   115  		if key.Comment == addedKey.Comment {
   116  			isFound = true
   117  		}
   118  	}
   119  	if !isFound {
   120  		t.Fatal("key with the updated comment not found")
   121  	}
   122  }
   123
View as plain text