~bigbes/sourcehut-dolt

sourcehut-dolt/db/keys_test.go -rw-r--r-- 2.2 KiB
d6f19a1f — Eugene Blikh build: source core-go from the instance fork 30 days ago 
                                                                                
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

package db

import (
	"bytes"
	"context"
	"errors"
	"testing"

	"go.bigb.es/sourcehut-dolt/core"
)

func TestDoltKeyLifecycle(t *testing.T) {
	s, db, cleanup := newTestStore(t)
	defer cleanup()
	ctx := context.Background()

	uid := insertUser(t, db, 1, "alice", core.UserTypeUser)
	pub := bytes.Repeat([]byte{0xab}, 32)

	key, err := s.InsertKey(ctx, uid, "kid-one", pub, "laptop")
	if err != nil {
		t.Fatalf("insert key: %v", err)
	}
	if key.ID == 0 {
		t.Fatal("expected non-zero key id")
	}

	// Duplicate kid → ErrKeyExists.
	if _, err := s.InsertKey(ctx, uid, "kid-one", pub, "dup"); !errors.Is(err, ErrKeyExists) {
		t.Fatalf("expected ErrKeyExists, got %v", err)
	}

	// KeyByKID returns pubkey + user identity for authn.
	ka, err := s.KeyByKID(ctx, "kid-one")
	if err != nil {
		t.Fatalf("key by kid: %v", err)
	}
	if ka.UserID != uid || ka.Username != "alice" || ka.UserType != core.UserTypeUser {
		t.Fatalf("unexpected key auth identity: %+v", ka)
	}
	if !bytes.Equal(ka.PubKey, pub) {
		t.Fatalf("pubkey mismatch: %x", ka.PubKey)
	}

	// Missing kid → ErrNotFound.
	if _, err := s.KeyByKID(ctx, "absent"); !errors.Is(err, ErrNotFound) {
		t.Fatalf("expected ErrNotFound, got %v", err)
	}

	// TouchKeyLastUsed sets last_used.
	if err := s.TouchKeyLastUsed(ctx, "kid-one"); err != nil {
		t.Fatalf("touch: %v", err)
	}
	keys, err := s.ListKeysByUser(ctx, uid)
	if err != nil {
		t.Fatalf("list keys: %v", err)
	}
	if len(keys) != 1 || keys[0].Comment != "laptop" || keys[0].LastUsed == nil {
		t.Fatalf("unexpected keys after touch: %+v", keys)
	}

	// Touching an absent kid → ErrNotFound.
	if err := s.TouchKeyLastUsed(ctx, "absent"); !errors.Is(err, ErrNotFound) {
		t.Fatalf("expected ErrNotFound touching absent, got %v", err)
	}

	// DeleteKey is scoped by user: wrong user cannot delete.
	if err := s.DeleteKey(ctx, key.ID, 999); !errors.Is(err, ErrNotFound) {
		t.Fatalf("expected ErrNotFound deleting other user's key, got %v", err)
	}
	if err := s.DeleteKey(ctx, key.ID, uid); err != nil {
		t.Fatalf("delete own key: %v", err)
	}
	keys, err = s.ListKeysByUser(ctx, uid)
	if err != nil {
		t.Fatalf("list after delete: %v", err)
	}
	if len(keys) != 0 {
		t.Fatalf("expected no keys after delete, got %d", len(keys))
	}
}