115 lines
4 KiB
Go
115 lines
4 KiB
Go
package rpc
|
|
|
|
import (
|
|
"context"
|
|
"testing"
|
|
|
|
"github.com/iamxvbaba/td/bin"
|
|
"github.com/iamxvbaba/td/clock"
|
|
"github.com/iamxvbaba/td/tg"
|
|
"github.com/iamxvbaba/td/tgerr"
|
|
"go.uber.org/zap/zaptest"
|
|
|
|
appauth "telesrv/internal/app/auth"
|
|
"telesrv/internal/domain"
|
|
"telesrv/internal/store"
|
|
"telesrv/internal/store/memory"
|
|
)
|
|
|
|
func TestAccountResetAuthorizationKeepsProtocolKeyAndReturnsRPC401(t *testing.T) {
|
|
ctx := context.Background()
|
|
currentAuthKeyID := [8]byte{0x71}
|
|
targetAuthKeyID := [8]byte{0x72}
|
|
const targetHash = int64(2026072401)
|
|
|
|
authKeys := memory.NewAuthKeyStore()
|
|
authorizations := memory.NewAuthorizationStore()
|
|
users := memory.NewUserStore()
|
|
user, err := users.Create(ctx, domain.User{Phone: "15550009001", FirstName: "Auth"})
|
|
if err != nil {
|
|
t.Fatalf("create authorization owner: %v", err)
|
|
}
|
|
userID := user.ID
|
|
for _, authKeyID := range [][8]byte{currentAuthKeyID, targetAuthKeyID} {
|
|
if err := authKeys.Save(ctx, store.AuthKeyData{ID: authKeyID}); err != nil {
|
|
t.Fatalf("save auth key %x: %v", authKeyID, err)
|
|
}
|
|
}
|
|
authService := appauth.NewService(users, authorizations, nil, authKeys, nil, "12345")
|
|
if err := authorizations.Bind(ctx, domain.Authorization{
|
|
AuthKeyID: currentAuthKeyID,
|
|
UserID: userID,
|
|
Hash: 2026072400,
|
|
}); err != nil {
|
|
t.Fatalf("bind current authorization: %v", err)
|
|
}
|
|
if err := authorizations.Bind(ctx, domain.Authorization{
|
|
AuthKeyID: targetAuthKeyID,
|
|
UserID: userID,
|
|
Hash: targetHash,
|
|
}); err != nil {
|
|
t.Fatalf("bind target authorization: %v", err)
|
|
}
|
|
|
|
r := New(Config{}, Deps{
|
|
Auth: authService,
|
|
Files: &fakeFiles{},
|
|
}, zaptest.NewLogger(t), clock.System)
|
|
|
|
var warmTarget bin.Buffer
|
|
if err := (&tg.UploadSaveFilePartRequest{
|
|
FileID: 1,
|
|
FilePart: 0,
|
|
Bytes: []byte{1},
|
|
}).Encode(&warmTarget); err != nil {
|
|
t.Fatalf("encode target warm-up RPC: %v", err)
|
|
}
|
|
if _, err := r.Dispatch(ctx, targetAuthKeyID, 101, &warmTarget); err != nil {
|
|
t.Fatalf("target warm-up RPC: %v", err)
|
|
}
|
|
|
|
var reset bin.Buffer
|
|
if err := (&tg.AccountResetAuthorizationRequest{Hash: targetHash}).Encode(&reset); err != nil {
|
|
t.Fatalf("encode account.resetAuthorization: %v", err)
|
|
}
|
|
if result, err := r.Dispatch(ctx, currentAuthKeyID, 102, &reset); err != nil {
|
|
t.Fatalf("account.resetAuthorization: %v", err)
|
|
} else if value, ok := dispatchCanonicalValue(result).(bool); !ok || !value {
|
|
t.Fatalf("account.resetAuthorization result = %#v, want true", dispatchCanonicalValue(result))
|
|
}
|
|
|
|
if _, found, err := authKeys.Get(ctx, targetAuthKeyID); err != nil || !found {
|
|
t.Fatalf("target protocol auth key found=%v err=%v, want retained", found, err)
|
|
}
|
|
if _, found, err := authorizations.ByAuthKey(ctx, targetAuthKeyID); err != nil || found {
|
|
t.Fatalf("target business authorization found=%v err=%v, want removed", found, err)
|
|
}
|
|
if current, found, err := authorizations.ByAuthKey(ctx, currentAuthKeyID); err != nil || !found || current.UserID != userID {
|
|
t.Fatalf("current authorization=%+v found=%v err=%v, want retained user %d", current, found, err, userID)
|
|
}
|
|
|
|
var afterRevoke bin.Buffer
|
|
if err := (&tg.UploadSaveFilePartRequest{
|
|
FileID: 1,
|
|
FilePart: 1,
|
|
Bytes: []byte{2},
|
|
}).Encode(&afterRevoke); err != nil {
|
|
t.Fatalf("encode target post-revoke RPC: %v", err)
|
|
}
|
|
if _, err := r.Dispatch(ctx, targetAuthKeyID, 103, &afterRevoke); !tgerr.Is(err, "AUTH_KEY_UNREGISTERED") {
|
|
t.Fatalf("target post-revoke RPC err=%v, want AUTH_KEY_UNREGISTERED", err)
|
|
}
|
|
|
|
var logout bin.Buffer
|
|
if err := (&tg.AuthLogOutRequest{}).Encode(&logout); err != nil {
|
|
t.Fatalf("encode target auth.logOut cleanup: %v", err)
|
|
}
|
|
if result, err := r.Dispatch(ctx, targetAuthKeyID, 104, &logout); err != nil {
|
|
t.Fatalf("target auth.logOut cleanup: %v", err)
|
|
} else if _, ok := dispatchCanonicalValue(result).(*tg.AuthLoggedOut); !ok {
|
|
t.Fatalf("target auth.logOut cleanup result=%#v, want *tg.AuthLoggedOut", dispatchCanonicalValue(result))
|
|
}
|
|
if _, found, err := authKeys.Get(ctx, targetAuthKeyID); err != nil || !found {
|
|
t.Fatalf("target protocol auth key after logout cleanup found=%v err=%v, want retained", found, err)
|
|
}
|
|
}
|