internal/mtprotoedge/layer_profile_test.go
Rama main · réplica de lectura del repositorio original.
package mtprotoedge
import (
"context"
"errors"
"fmt"
"sync"
"testing"
"github.com/iamxvbaba/td/tlprofile"
)
type countingInheritedLayerResolver struct {
LayerRPCHandler
calls int
layer int
found bool
err error
}
type orderedSessionLayerResolver struct {
LayerRPCHandler
layer int
msgID int64
found bool
}
const testFutureLayer = int(tlprofile.ProfileCanonical) + 1
func (r *orderedSessionLayerResolver) NegotiatedSessionLayerEvidence([8]byte, int64) (int, int64, bool) {
return r.layer, r.msgID, r.found
}
func (r *countingInheritedLayerResolver) ResolveInheritedAuthKeyLayer(context.Context, [8]byte) (int, bool, error) {
r.calls++
return r.layer, r.found, r.err
}
func TestConnLayerProfileUnknownFreezeAndIdempotence(t *testing.T) {
c := &Conn{}
if profile, ok := c.LayerProfile(); ok || profile != 0 {
t.Fatalf("initial LayerProfile = (%d, %v), want (0, false)", profile, ok)
}
if err := c.FreezeLayerProfile(tlprofile.Profile225); err != nil {
t.Fatalf("freeze layer 225: %v", err)
}
if err := c.FreezeLayerProfile(tlprofile.Profile225); err != nil {
t.Fatalf("repeat freeze layer 225: %v", err)
}
if profile, ok := c.LayerProfile(); !ok || profile != tlprofile.Profile225 {
t.Fatalf("LayerProfile = (%d, %v), want (225, true)", profile, ok)
}
}
func TestConnLayerProfileInheritedCanBeCorrectedExplicitly(t *testing.T) {
c := &Conn{}
if err := c.SeedInheritedLayerProfile(tlprofile.Profile225); err != nil {
t.Fatalf("seed inherited layer 225: %v", err)
}
initial := c.LayerProfileState()
if initial.Profile != tlprofile.Profile225 || initial.Origin != LayerProfileInherited || initial.Epoch != 1 {
t.Fatalf("initial inherited state = %#v", initial)
}
if err := c.SeedInheritedLayerProfile(tlprofile.Profile226); err != nil {
t.Fatalf("repeat inherited seed: %v", err)
}
if got := c.LayerProfileState(); got != initial {
t.Fatalf("second inherited seed replaced selected default: got %#v want %#v", got, initial)
}
if err := c.FreezeLayerProfile(tlprofile.Profile225); err != nil {
t.Fatalf("promote inherited evidence: %v", err)
}
promoted := c.LayerProfileState()
if promoted.Profile != tlprofile.Profile225 || promoted.Origin != LayerProfileExplicit || promoted.Epoch != initial.Epoch+1 {
t.Fatalf("promoted explicit state = %#v", promoted)
}
if err := c.FreezeLayerProfile(tlprofile.Profile227); err != nil {
t.Fatalf("correct explicit layer: %v", err)
}
corrected := c.LayerProfileState()
if corrected.Profile != tlprofile.Profile227 || corrected.Origin != LayerProfileExplicit || corrected.Epoch != promoted.Epoch+1 {
t.Fatalf("corrected explicit state = %#v", corrected)
}
}
func TestConnSeedLayerProfile(t *testing.T) {
c := &Conn{}
if err := c.SeedLayerProfile(tlprofile.Profile226); err != nil {
t.Fatalf("seed layer 226: %v", err)
}
if err := c.SeedLayerProfile(tlprofile.Profile226); err != nil {
t.Fatalf("repeat seed layer 226: %v", err)
}
if err := c.FreezeLayerProfile(tlprofile.Profile226); err != nil {
t.Fatalf("freeze seeded layer 226: %v", err)
}
if profile, ok := c.LayerProfile(); !ok || profile != tlprofile.Profile226 {
t.Fatalf("LayerProfile = (%d, %v), want (226, true)", profile, ok)
}
}
func TestConnLayerProfileRejectsUnsupported(t *testing.T) {
for _, profile := range []tlprofile.Profile{0, 219, tlprofile.Profile(testFutureLayer)} {
t.Run(fmt.Sprintf("layer_%d", profile), func(t *testing.T) {
c := &Conn{}
if err := c.FreezeLayerProfile(profile); !errors.Is(err, ErrLayerProfileUnsupported) {
t.Fatalf("FreezeLayerProfile(%d) error = %v, want ErrLayerProfileUnsupported", profile, err)
}
if err := c.SeedLayerProfile(profile); !errors.Is(err, ErrLayerProfileUnsupported) {
t.Fatalf("SeedLayerProfile(%d) error = %v, want ErrLayerProfileUnsupported", profile, err)
}
if got, ok := c.LayerProfile(); ok || got != 0 {
t.Fatalf("LayerProfile after invalid values = (%d, %v), want (0, false)", got, ok)
}
})
}
}
func TestConnLayerProfileConcurrentCorrectionsRemainAtomic(t *testing.T) {
const goroutines = 128
c := &Conn{}
start := make(chan struct{})
errs := make([]error, goroutines)
profiles := make([]tlprofile.Profile, goroutines)
var wg sync.WaitGroup
wg.Add(goroutines)
for i := range goroutines {
profile := tlprofile.Profile225
if i%2 != 0 {
profile = tlprofile.Profile227
}
profiles[i] = profile
go func(index int, requested tlprofile.Profile) {
defer wg.Done()
<-start
errs[index] = c.FreezeLayerProfile(requested)
}(i, profile)
}
close(start)
wg.Wait()
state := c.LayerProfileState()
if state.Origin != LayerProfileExplicit || (state.Profile != tlprofile.Profile225 && state.Profile != tlprofile.Profile227) {
t.Fatalf("concurrent final state = %#v, want supported explicit contender", state)
}
if state.Epoch == 0 || state.Epoch > goroutines {
t.Fatalf("concurrent epoch = %d, want 1..%d", state.Epoch, goroutines)
}
for i, err := range errs {
if err != nil {
t.Fatalf("correction contender %d (%d) returned error: %v", i, profiles[i], err)
}
}
}
func TestConnLayerProfileEvidenceUsesClientMessageOrder(t *testing.T) {
c := &Conn{}
if err := c.seedOrderedLayerProfile(tlprofile.Profile225, 100); err != nil {
t.Fatal(err)
}
if applied, err := c.FreezeLayerProfileAt(tlprofile.Profile227, 104); err != nil || !applied {
t.Fatalf("newer correction applied=%v err=%v", applied, err)
}
corrected := c.LayerProfileState()
if applied, err := c.FreezeLayerProfileAt(tlprofile.Profile225, 100); err != nil || applied {
t.Fatalf("old duplicate applied=%v err=%v", applied, err)
}
if got := c.LayerProfileState(); got != corrected {
t.Fatalf("old duplicate changed profile: got %#v want %#v", got, corrected)
}
if applied, err := c.FreezeLayerProfileAt(tlprofile.Profile225, 104); !errors.Is(err, ErrLayerProfileConflict) || applied {
t.Fatalf("same-msg conflicting evidence applied=%v err=%v", applied, err)
}
if applied, err := c.FreezeLayerProfileAt(tlprofile.Profile227, 108); err != nil || !applied {
t.Fatalf("same-layer newer evidence applied=%v err=%v", applied, err)
}
state, msgID := c.layerProfileEvidenceState()
if state != corrected || msgID != 108 {
t.Fatalf("same-layer cursor advance = state:%#v msgID:%d, want state:%#v msgID:108", state, msgID, corrected)
}
}
func TestSessionManagerSeedsOnlyUnknownRawAuthKeyConnections(t *testing.T) {
m := NewSessionManager(nil)
authKeyID := [8]byte{2, 2, 7}
unknown := &Conn{authKeyID: authKeyID, sessionID: 1}
explicit := &Conn{authKeyID: authKeyID, sessionID: 2}
inherited := &Conn{authKeyID: authKeyID, sessionID: 3}
if err := explicit.FreezeLayerProfile(tlprofile.Profile225); err != nil {
t.Fatal(err)
}
if err := inherited.SeedInheritedLayerProfile(tlprofile.Profile226); err != nil {
t.Fatal(err)
}
for _, c := range []*Conn{unknown, explicit, inherited} {
if err := m.Register(c); err != nil {
t.Fatal(err)
}
}
if seeded := m.SeedInheritedLayerForRawAuthKey(authKeyID, 227); seeded != 1 {
t.Fatalf("seeded connections = %d, want 1", seeded)
}
if got := unknown.LayerProfileState(); got.Profile != tlprofile.Profile227 || got.Origin != LayerProfileInherited {
t.Fatalf("unknown connection seed = %#v", got)
}
if got := explicit.LayerProfileState(); got.Profile != tlprofile.Profile225 || got.Origin != LayerProfileExplicit {
t.Fatalf("explicit connection was overwritten = %#v", got)
}
if got := inherited.LayerProfileState(); got.Profile != tlprofile.Profile226 || got.Origin != LayerProfileInherited {
t.Fatalf("existing inherited connection was overwritten = %#v", got)
}
if seeded := m.SeedInheritedLayerForRawAuthKey(authKeyID, testFutureLayer); seeded != 0 {
t.Fatalf("unsupported layer seeded %d connections", seeded)
}
}
func TestSessionManagerRefreshesInheritedRawKeyShadowAtBind(t *testing.T) {
m := NewSessionManager(nil)
authKeyID := [8]byte{2, 2, 8}
unknown := &Conn{authKeyID: authKeyID, sessionID: 1}
inherited := &Conn{authKeyID: authKeyID, sessionID: 2}
explicit := &Conn{authKeyID: authKeyID, sessionID: 3}
if err := inherited.SeedInheritedLayerProfile(tlprofile.Profile225); err != nil {
t.Fatal(err)
}
if err := explicit.FreezeLayerProfile(tlprofile.Profile225); err != nil {
t.Fatal(err)
}
for _, c := range []*Conn{unknown, inherited, explicit} {
if err := m.Register(c); err != nil {
t.Fatal(err)
}
}
if refreshed := m.RefreshInheritedLayerForRawAuthKey(authKeyID, 227); refreshed != 2 {
t.Fatalf("refreshed connections = %d, want 2", refreshed)
}
for name, c := range map[string]*Conn{"unknown": unknown, "inherited": inherited} {
if got := c.LayerProfileState(); got.Profile != tlprofile.Profile227 || got.Origin != LayerProfileInherited {
t.Fatalf("%s refresh = %#v", name, got)
}
}
if got := explicit.LayerProfileState(); got.Profile != tlprofile.Profile225 || got.Origin != LayerProfileExplicit {
t.Fatalf("explicit evidence overwritten = %#v", got)
}
}
func TestSessionManagerClearsOnlyInheritedRawKeyShadowAtBind(t *testing.T) {
m := NewSessionManager(nil)
authKeyID := [8]byte{2, 2, 81}
inherited := &Conn{authKeyID: authKeyID, sessionID: 1}
explicit := &Conn{authKeyID: authKeyID, sessionID: 2}
unknown := &Conn{authKeyID: authKeyID, sessionID: 3}
if err := inherited.SeedInheritedLayerProfile(tlprofile.Profile225); err != nil {
t.Fatal(err)
}
if err := explicit.seedOrderedLayerProfile(tlprofile.Profile227, 104); err != nil {
t.Fatal(err)
}
for _, c := range []*Conn{inherited, explicit, unknown} {
if err := m.Register(c); err != nil {
t.Fatal(err)
}
}
if cleared := m.ClearInheritedLayerForRawAuthKey(authKeyID); cleared != 1 {
t.Fatalf("cleared connections = %d, want 1", cleared)
}
if got := inherited.LayerProfileState(); got.Origin != LayerProfileUnknown || got.Profile != 0 {
t.Fatalf("inherited shadow after clear = %#v, want unknown", got)
}
if got := explicit.LayerProfileState(); got.Profile != tlprofile.Profile227 || got.Origin != LayerProfileExplicit {
t.Fatalf("explicit evidence was cleared = %#v", got)
}
if state, msgID := explicit.layerProfileEvidenceState(); state.Origin != LayerProfileExplicit || msgID != 104 {
t.Fatalf("explicit ordered evidence changed = %#v msgID:%d", state, msgID)
}
if got := unknown.LayerProfileState(); got.Origin != LayerProfileUnknown || got.Profile != 0 {
t.Fatalf("unknown state changed = %#v", got)
}
if cleared := m.ClearInheritedLayerForRawAuthKey(authKeyID); cleared != 0 {
t.Fatalf("idempotent clear changed %d connections", cleared)
}
}
func TestSessionManagerSeedsUnknownSessionsAcrossBusinessAuthKey(t *testing.T) {
m := NewSessionManager(nil)
permAuthKeyID := [8]byte{9, 9, 9}
rawOne := [8]byte{9, 9, 1}
rawTwo := [8]byte{9, 9, 2}
first := &Conn{authKeyID: rawOne, sessionID: 1}
second := &Conn{authKeyID: rawTwo, sessionID: 2}
explicit := &Conn{authKeyID: rawTwo, sessionID: 3}
inherited := &Conn{authKeyID: rawOne, sessionID: 4}
if err := explicit.FreezeLayerProfile(tlprofile.Profile225); err != nil {
t.Fatal(err)
}
if err := inherited.SeedInheritedLayerProfile(tlprofile.Profile225); err != nil {
t.Fatal(err)
}
for _, c := range []*Conn{first, second, explicit, inherited} {
if err := m.Register(c); err != nil {
t.Fatal(err)
}
m.BindAuthKeyForSession(c.authKeyID, c.sessionID, permAuthKeyID)
}
if seeded := m.SeedInheritedLayerForBusinessAuthKey(permAuthKeyID, 227); seeded != 2 {
t.Fatalf("business auth-key seeded=%d, want 2", seeded)
}
for name, c := range map[string]*Conn{"first": first, "second": second} {
if got := c.LayerProfileState(); got.Profile != tlprofile.Profile227 || got.Origin != LayerProfileInherited {
t.Fatalf("%s business default = %#v", name, got)
}
}
if got := explicit.LayerProfileState(); got.Profile != tlprofile.Profile225 || got.Origin != LayerProfileExplicit {
t.Fatalf("business seed overwrote explicit = %#v", got)
}
if got := inherited.LayerProfileState(); got.Profile != tlprofile.Profile225 || got.Origin != LayerProfileInherited {
t.Fatalf("business seed overwrote inherited = %#v", got)
}
}
func TestSessionManagerExplicitLayerEvidenceUsesLiveExactSession(t *testing.T) {
m := NewSessionManager(nil)
authKeyID := [8]byte{2, 2, 9}
const sessionID = int64(229)
c := &Conn{authKeyID: authKeyID, sessionID: sessionID}
if err := c.seedOrderedLayerProfile(tlprofile.Profile226, 1234); err != nil {
t.Fatal(err)
}
if err := m.Register(c); err != nil {
t.Fatal(err)
}
if layer, msgID, ok := m.ExplicitLayerEvidenceForAuthKey(authKeyID, sessionID); !ok || layer != 226 || msgID != 1234 {
t.Fatalf("live explicit evidence = (%d,%d,%v)", layer, msgID, ok)
}
inherited := &Conn{authKeyID: authKeyID, sessionID: sessionID + 1}
if err := inherited.SeedInheritedLayerProfile(tlprofile.Profile227); err != nil {
t.Fatal(err)
}
if err := m.Register(inherited); err != nil {
t.Fatal(err)
}
if layer, msgID, ok := m.ExplicitLayerEvidenceForAuthKey(authKeyID, sessionID+1); ok || layer != 0 || msgID != 0 {
t.Fatalf("inherited state exposed as explicit = (%d,%d,%v)", layer, msgID, ok)
}
}
func TestSessionManagerExplicitLayerEvidenceChoosesNewestActiveOrClaim(t *testing.T) {
m := NewSessionManager(nil)
authKeyID := [8]byte{2, 3, 0}
const sessionID = int64(230)
active := &Conn{authKeyID: authKeyID, sessionID: sessionID}
claim := &Conn{authKeyID: authKeyID, sessionID: sessionID}
if err := active.seedOrderedLayerProfile(tlprofile.Profile225, 100); err != nil {
t.Fatal(err)
}
if err := claim.seedOrderedLayerProfile(tlprofile.Profile227, 104); err != nil {
t.Fatal(err)
}
key := sessionKey{authKeyID: authKeyID, sessionID: sessionID}
m.mu.Lock()
m.bySession[key] = active
m.claims[key] = claim
m.mu.Unlock()
if layer, msgID, ok := m.ExplicitLayerEvidenceForAuthKey(authKeyID, sessionID); !ok || layer != 227 || msgID != 104 {
t.Fatalf("newest active/claim evidence = (%d,%d,%v)", layer, msgID, ok)
}
claim.retire()
if layer, msgID, ok := m.ExplicitLayerEvidenceForAuthKey(authKeyID, sessionID); !ok || layer != 225 || msgID != 100 {
t.Fatalf("retired claim shadowed active evidence = (%d,%d,%v)", layer, msgID, ok)
}
}
func TestOrderedSessionLayerBroadcastConvergesAcrossPhysicalGenerations(t *testing.T) {
m := NewSessionManager(nil)
authKeyID := [8]byte{3, 0, 0}
const sessionID = int64(300)
oldPhysical := &Conn{authKeyID: authKeyID, sessionID: sessionID}
current := &Conn{authKeyID: authKeyID, sessionID: sessionID}
m.mu.Lock()
m.bySession[sessionKey{authKeyID: authKeyID, sessionID: sessionID}] = current
m.mu.Unlock()
if applied, err := m.ApplyOrderedLayerProfileForSession(oldPhysical, authKeyID, sessionID, tlprofile.Profile227, 300); err != nil || applied != 2 {
t.Fatalf("newer broadcast applied=%d err=%v", applied, err)
}
if applied, err := m.ApplyOrderedLayerProfileForSession(oldPhysical, authKeyID, sessionID, tlprofile.Profile225, 200); err != nil || applied != 0 {
t.Fatalf("delayed older broadcast applied=%d err=%v", applied, err)
}
for name, c := range map[string]*Conn{"old": oldPhysical, "current": current} {
state, msgID := c.layerProfileEvidenceState()
if state.Profile != tlprofile.Profile227 || state.Origin != LayerProfileExplicit || msgID != 300 {
t.Fatalf("%s physical state = %#v msgID:%d", name, state, msgID)
}
}
}
func TestInitialProfileSeedAvoidsPermanentKeyResolverAndPrefersPermForTemp(t *testing.T) {
t.Run("fetched permanent metadata is authoritative fast path", func(t *testing.T) {
resolver := &countingInheritedLayerResolver{layer: 225, found: true}
s := &Server{layerRPC: resolver}
c := &Conn{authKeyExpiresAt: 0}
if err := s.seedInitialLayerProfile(context.Background(), c, 227, LayerProfileSnapshot{}); err != nil {
t.Fatal(err)
}
if resolver.calls != 0 {
t.Fatalf("permanent resolver calls = %d, want 0", resolver.calls)
}
if got := c.LayerProfileState(); got.Profile != tlprofile.Profile227 || got.Origin != LayerProfileInherited {
t.Fatalf("permanent seed = %#v", got)
}
})
t.Run("temporary key resolves permanent before raw shadow", func(t *testing.T) {
resolver := &countingInheritedLayerResolver{layer: 227, found: true}
s := &Server{layerRPC: resolver}
c := &Conn{authKeyExpiresAt: 1_900_000_000}
if err := s.seedInitialLayerProfile(context.Background(), c, 225, LayerProfileSnapshot{}); err != nil {
t.Fatal(err)
}
if resolver.calls != 1 {
t.Fatalf("temporary resolver calls = %d, want 1", resolver.calls)
}
if got := c.LayerProfileState(); got.Profile != tlprofile.Profile227 || got.Origin != LayerProfileInherited {
t.Fatalf("temporary canonical seed = %#v", got)
}
})
t.Run("unsupported permanent metadata stays unknown", func(t *testing.T) {
resolver := &countingInheritedLayerResolver{layer: 227, found: true}
s := &Server{layerRPC: resolver}
c := &Conn{authKeyExpiresAt: 0}
if err := s.seedInitialLayerProfile(context.Background(), c, testFutureLayer, LayerProfileSnapshot{}); err != nil {
t.Fatal(err)
}
if resolver.calls != 0 {
t.Fatalf("unsupported permanent metadata fell through to resolver")
}
if got := c.LayerProfileState(); got.Origin != LayerProfileUnknown {
t.Fatalf("unsupported permanent seed = %#v", got)
}
})
t.Run("unsupported bound permanent blocks raw temp shadow", func(t *testing.T) {
resolver := &countingInheritedLayerResolver{layer: testFutureLayer, found: true}
s := &Server{layerRPC: resolver}
c := &Conn{authKeyExpiresAt: 1_900_000_000}
if err := s.seedInitialLayerProfile(context.Background(), c, 225, LayerProfileSnapshot{}); err != nil {
t.Fatal(err)
}
if got := c.LayerProfileState(); got.Origin != LayerProfileUnknown {
t.Fatalf("authoritative unsupported perm fell back to raw shadow = %#v", got)
}
})
}
func TestInitialProfileSeedRestoresOrderedExactSessionEvidence(t *testing.T) {
resolver := &orderedSessionLayerResolver{layer: 226, msgID: 123456, found: true}
s := &Server{layerRPC: resolver}
c := &Conn{authKeyExpiresAt: 0}
if err := s.seedInitialLayerProfile(context.Background(), c, 227, LayerProfileSnapshot{}); err != nil {
t.Fatal(err)
}
state, msgID := c.layerProfileEvidenceState()
if state.Profile != tlprofile.Profile226 || state.Origin != LayerProfileExplicit || msgID != resolver.msgID {
t.Fatalf("ordered exact seed = state:%#v msgID:%d", state, msgID)
}
}
func TestInheritedLayerResolverFailureLeavesExplicitRecoveryAvailable(t *testing.T) {
resolverErr := errors.New("temporary resolver unavailable")
resolver := &countingInheritedLayerResolver{err: resolverErr}
s := &Server{layerRPC: resolver}
c := &Conn{authKeyExpiresAt: 1_900_000_000}
if err := s.seedInitialLayerProfile(context.Background(), c, 225, LayerProfileSnapshot{}); err != nil {
t.Fatalf("optional inherited resolver error escaped: %v", err)
}
if got := c.LayerProfileState(); got.Origin != LayerProfileUnknown {
t.Fatalf("resolver error selected stale fallback = %#v", got)
}
}
func TestInheritedLayerResolverAvailabilityUsesOnlySupportedRawTempShadow(t *testing.T) {
for _, tt := range []struct {
name string
fetchedLayer int
wantProfile tlprofile.Profile
wantOrigin LayerProfileOrigin
}{
{name: "supported raw shadow", fetchedLayer: 225, wantProfile: tlprofile.Profile225, wantOrigin: LayerProfileInherited},
{name: "future raw shadow stays unknown", fetchedLayer: testFutureLayer, wantOrigin: LayerProfileUnknown},
} {
t.Run(tt.name, func(t *testing.T) {
resolver := &countingInheritedLayerResolver{err: layerDurabilityUnavailableTestError{}}
s := &Server{layerRPC: resolver}
c := &Conn{authKeyExpiresAt: 1_900_000_000}
if err := s.seedInitialLayerProfile(context.Background(), c, tt.fetchedLayer, LayerProfileSnapshot{}); err != nil {
t.Fatal(err)
}
if resolver.calls != 1 {
t.Fatalf("resolver calls=%d, want 1", resolver.calls)
}
if got := c.LayerProfileState(); got.Profile != tt.wantProfile || got.Origin != tt.wantOrigin {
t.Fatalf("availability seed = %#v, want profile=%d origin=%d", got, tt.wantProfile, tt.wantOrigin)
}
})
}
}
func TestActivationClaimRecheckClosesTempBindLayerRace(t *testing.T) {
authKeyID := [8]byte{4, 0, 0}
t.Run("bind wins before claimed recheck", func(t *testing.T) {
resolver := &countingInheritedLayerResolver{found: false}
s := &Server{layerRPC: resolver}
m := NewSessionManager(nil)
c := &Conn{authKeyID: authKeyID, sessionID: 401, authKeyExpiresAt: 1_900_000_000}
if err := s.seedInitialLayerProfile(context.Background(), c, 225, LayerProfileSnapshot{}); err != nil {
t.Fatal(err)
}
if err := m.BeginActivation(c); err != nil {
t.Fatal(err)
}
defer m.AbortActivation(c)
resolver.layer, resolver.found = 227, true
if err := s.refreshActivatedInheritedLayerProfile(context.Background(), c, 225); err != nil {
t.Fatal(err)
}
if got := c.LayerProfileState(); got.Profile != tlprofile.Profile227 || got.Origin != LayerProfileInherited {
t.Fatalf("post-claim permanent recheck = %#v", got)
}
})
t.Run("claim wins before bind refresh", func(t *testing.T) {
m := NewSessionManager(nil)
c := &Conn{authKeyID: authKeyID, sessionID: 402, authKeyExpiresAt: 1_900_000_000}
if err := c.SeedInheritedLayerProfile(tlprofile.Profile225); err != nil {
t.Fatal(err)
}
if err := m.BeginActivation(c); err != nil {
t.Fatal(err)
}
defer m.AbortActivation(c)
if refreshed := m.RefreshInheritedLayerForRawAuthKey(authKeyID, 227); refreshed != 1 {
t.Fatalf("bind refresh count = %d, want 1", refreshed)
}
if got := c.LayerProfileState(); got.Profile != tlprofile.Profile227 || got.Origin != LayerProfileInherited {
t.Fatalf("claim-visible bind refresh = %#v", got)
}
})
t.Run("unsupported permanent clears preclaim raw shadow", func(t *testing.T) {
resolver := &countingInheritedLayerResolver{layer: testFutureLayer, found: true}
s := &Server{layerRPC: resolver}
c := &Conn{authKeyID: authKeyID, sessionID: 403, authKeyExpiresAt: 1_900_000_000}
if err := c.SeedInheritedLayerProfile(tlprofile.Profile225); err != nil {
t.Fatal(err)
}
if err := s.refreshActivatedInheritedLayerProfile(context.Background(), c, 225); err != nil {
t.Fatal(err)
}
if got := c.LayerProfileState(); got.Origin != LayerProfileUnknown {
t.Fatalf("unsupported permanent kept stale raw shadow = %#v", got)
}
})
t.Run("availability outage retains current raw shadow", func(t *testing.T) {
resolver := &countingInheritedLayerResolver{err: layerDurabilityUnavailableTestError{}}
s := &Server{layerRPC: resolver}
c := &Conn{authKeyID: authKeyID, sessionID: 404, authKeyExpiresAt: 1_900_000_000}
if err := s.refreshActivatedInheritedLayerProfile(context.Background(), c, 225); err != nil {
t.Fatal(err)
}
if got := c.LayerProfileState(); got.Profile != tlprofile.Profile225 || got.Origin != LayerProfileInherited {
t.Fatalf("availability recheck lost raw shadow = %#v", got)
}
})
t.Run("structural resolver failure clears preclaim raw shadow", func(t *testing.T) {
resolver := &countingInheritedLayerResolver{err: errors.New("invalid binding identity")}
s := &Server{layerRPC: resolver}
c := &Conn{authKeyID: authKeyID, sessionID: 405, authKeyExpiresAt: 1_900_000_000}
if err := c.SeedInheritedLayerProfile(tlprofile.Profile225); err != nil {
t.Fatal(err)
}
if err := s.refreshActivatedInheritedLayerProfile(context.Background(), c, 225); err != nil {
t.Fatal(err)
}
if got := c.LayerProfileState(); got.Origin != LayerProfileUnknown {
t.Fatalf("structural resolver failure retained raw shadow = %#v", got)
}
})
}