narelay: drop noisy warning on no prior user data

carstore/nonarchive.go

···
 
 func (cs *NonArchivalCarstore) loadCommitRefInfo(ctx context.Context, user models.Uid) (*commitRefInfo, error) {
 	var out commitRefInfo
-	if err := cs.db.Find(&out, "uid = ?", user).Error; err != nil {
-		return nil, err
+	wat := cs.db.Find(&out, "uid = ?", user)
+	if wat.Error != nil {
+		return nil, wat.Error
+	}
+	if wat.RowsAffected == 0 {
+		return nil, nil
 	}
-
 	return &out, nil
 }
 
···
 	if err != nil {
 		return nil, err
 	}
+	if lastShard == nil {
+		return nil, nil
+	}
 
 	cs.putLastShardCache(lastShard)
 	return lastShard, nil
···
 	return nil
 }
 
+var commitRefZero = commitRefInfo{}
+
 func (cs *NonArchivalCarstore) NewDeltaSession(ctx context.Context, user models.Uid, since *string) (*DeltaSession, error) {
 	ctx, span := otel.Tracer("carstore").Start(ctx, "NewSession")
 	defer span.End()
···
 		return nil, err
 	}
 
-	if since != nil && *since != lastShard.Rev {
+	if lastShard == nil {
+		// ok, no previous user state to refer to
+		lastShard = &commitRefZero
+	} else if since != nil && *since != lastShard.Rev {
 		cs.log.Warn("revision mismatch", "commitSince", since, "lastRev", lastShard.Rev, "err", ErrRepoBaseMismatch)
 	}
 
···
 	if err != nil {
 		return cid.Undef, err
 	}
-	if lastShard.ID == 0 {
+	if lastShard == nil || lastShard.ID == 0 {
 		return cid.Undef, nil
 	}
 
···
 	if err != nil {
 		return "", err
 	}
-	if lastShard.ID == 0 {
+	if lastShard == nil || lastShard.ID == 0 {
 		return "", nil
 	}
 

testing/integ_test.go

···
 import (
 	"bytes"
 	"context"
-	"encoding/json"
-	"fmt"
 	"math/rand"
 	"strings"
 	"testing"
···
 	defer evts.Cancel()
 
 	bob := p1.MustNewUser(t, "bob.tpds")
-	fmt.Println("event 1")
+	t.Log("event 1")
 	e1 := evts.Next()
 	assert.NotNil(e1.RepoCommit)
 	assert.Equal(e1.RepoCommit.Repo, bob.DID())
 
 	alice := p1.MustNewUser(t, "alice.tpds")
-	fmt.Println("event 2")
+	t.Log("event 2")
 	e2 := evts.Next()
 	assert.NotNil(e2.RepoCommit)
 	assert.Equal(e2.RepoCommit.Repo, alice.DID())
···
 	_ = bp1
 	_ = ap1
 
-	fmt.Println("bob:", bob.DID())
-	fmt.Println("event 3")
+	t.Log("bob:", bob.DID())
+	t.Log("event 3")
 	e3 := evts.Next()
 	assert.Equal(e3.RepoCommit.Repo, bob.DID())
 	//assert.Equal(e3.RepoCommit.Ops[0].Kind, "createRecord")
 
-	fmt.Println("alice:", alice.DID())
-	fmt.Println("event 4")
+	t.Log("alice:", alice.DID())
+	t.Log("event 4")
 	e4 := evts.Next()
 	assert.Equal(e4.RepoCommit.Repo, alice.DID())
 	//assert.Equal(e4.RepoCommit.Ops[0].Kind, "createRecord")
···
 	pbevts := b1.Events(t, 2)
 	defer pbevts.Cancel()
 
-	fmt.Println("event 5")
+	t.Log("event 5")
 	pbe1 := pbevts.Next()
 	assert.Equal(*e3, *pbe1)
 }
···
 	time.Sleep(time.Millisecond * 100)
 
 	initevt := evts.Next()
-	fmt.Println(initevt.RepoCommit)
+	t.Log(initevt.RepoCommit)
 	hcevt := evts.Next()
-	fmt.Println(hcevt.RepoHandle)
+	t.Log(hcevt.RepoHandle)
 	idevt := evts.Next()
-	fmt.Println(idevt.RepoIdentity)
+	t.Log(idevt.RepoIdentity)
 }
 
 func TestAccountEvent(t *testing.T) {
···
 	time.Sleep(time.Millisecond * 100)
 
 	initevt := evts.Next()
-	fmt.Println(initevt.RepoCommit)
+	t.Log(initevt.RepoCommit)
 
 	// Takedown
 	acevt := evts.Next()
-	fmt.Println(acevt.RepoAccount)
+	t.Log(acevt.RepoAccount)
 	assert.Equal(acevt.RepoAccount.Did, u.DID())
 	assert.Equal(acevt.RepoAccount.Active, false)
 	assert.Equal(*acevt.RepoAccount.Status, events.AccountStatusTakendown)
 
 	// Reactivate
 	acevt = evts.Next()
-	fmt.Println(acevt.RepoAccount)
+	t.Log(acevt.RepoAccount)
 	assert.Equal(acevt.RepoAccount.Did, u.DID())
 	assert.Equal(acevt.RepoAccount.Active, true)
 	assert.Equal(*acevt.RepoAccount.Status, events.AccountStatusActive)
 
 	// Deactivate
 	acevt = evts.Next()
-	fmt.Println(acevt.RepoAccount)
+	t.Log(acevt.RepoAccount)
 	assert.Equal(acevt.RepoAccount.Did, u.DID())
 	assert.Equal(acevt.RepoAccount.Active, false)
 	assert.Equal(*acevt.RepoAccount.Status, events.AccountStatusDeactivated)
 
 	// Reactivate
 	acevt = evts.Next()
-	fmt.Println(acevt.RepoAccount)
+	t.Log(acevt.RepoAccount)
 	assert.Equal(acevt.RepoAccount.Did, u.DID())
 	assert.Equal(acevt.RepoAccount.Active, true)
 	assert.Equal(*acevt.RepoAccount.Status, events.AccountStatusActive)
 
 	// Suspend
 	acevt = evts.Next()
-	fmt.Println(acevt.RepoAccount)
+	t.Log(acevt.RepoAccount)
 	assert.Equal(acevt.RepoAccount.Did, u.DID())
 	assert.Equal(acevt.RepoAccount.Active, false)
 	assert.Equal(*acevt.RepoAccount.Status, events.AccountStatusSuspended)
 
 	// Reactivate
 	acevt = evts.Next()
-	fmt.Println(acevt.RepoAccount)
+	t.Log(acevt.RepoAccount)
 	assert.Equal(acevt.RepoAccount.Did, u.DID())
 	assert.Equal(acevt.RepoAccount.Active, true)
 	assert.Equal(*acevt.RepoAccount.Status, events.AccountStatusActive)
···
 	time.Sleep(time.Millisecond * 20)
 
 	acevt = evts.Next()
-	fmt.Println(acevt.RepoAccount)
+	t.Log(acevt.RepoAccount)
 	assert.Equal(acevt.RepoAccount.Did, u.DID())
 	assert.Equal(acevt.RepoAccount.Active, false)
 	assert.Equal(*acevt.RepoAccount.Status, events.AccountStatusTakendown)
···
 	time.Sleep(time.Millisecond * 20)
 
 	acevt = evts.Next()
-	fmt.Println(acevt.RepoAccount)
+	t.Log(acevt.RepoAccount)
 	assert.Equal(acevt.RepoAccount.Did, u.DID())
 	assert.Equal(acevt.RepoAccount.Active, true)
 	assert.Equal(*acevt.RepoAccount.Status, events.AccountStatusActive)
···
 
 	last := es2.Next()
 	assert.Equal(alice.did, last.RepoCommit.Repo)
-}
-
-func jsonPrint(v any) {
-	b, _ := json.Marshal(v)
-	fmt.Println(string(b))
 }
 
 func commitFromSlice(t *testing.T, slice []byte, rcid cid.Cid) *repo.SignedCommit {
···
 	defer evts.Cancel()
 
 	bob := p1.MustNewUser(t, "bob.tpds")
-	fmt.Println("event 1")
+	t.Log("event 1")
 	e1 := evts.Next()
 	assert.NotNil(e1.RepoCommit)
 	assert.Equal(e1.RepoCommit.Repo, bob.DID())
-	fmt.Println(e1.RepoCommit.Ops[0])
+	t.Log(e1.RepoCommit.Ops[0])
 
 	ctx := context.TODO()
 	rm := p1.server.Repoman()
···
 	}
 
 	e2 := evts.Next()
-	//fmt.Println(e2.RepoCommit.Ops[0])
+	//t.Log(e2.RepoCommit.Ops[0])
 	assert.Equal(len(e2.RepoCommit.Ops), 0)
 	assert.Equal(e2.RepoCommit.Repo, bob.DID())
 }