Ilia Denisov
131 lines
3.0 KiB
Go
131 lines
3.0 KiB
Go
package testkit
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"slices"
|
|
"time"
|
|
|
|
"galaxy/authsession/internal/domain/challenge"
|
|
"galaxy/authsession/internal/domain/common"
|
|
"galaxy/authsession/internal/domain/devicesession"
|
|
"galaxy/authsession/internal/domain/gatewayprojection"
|
|
)
|
|
|
|
func cloneChallenge(record challenge.Challenge) (challenge.Challenge, error) {
|
|
cloned := record
|
|
cloned.CodeHash = bytes.Clone(record.CodeHash)
|
|
cloned.Abuse = cloneAbuseMetadata(record.Abuse)
|
|
|
|
if record.Confirmation != nil {
|
|
confirmation, err := cloneChallengeConfirmation(*record.Confirmation)
|
|
if err != nil {
|
|
return challenge.Challenge{}, err
|
|
}
|
|
cloned.Confirmation = &confirmation
|
|
}
|
|
|
|
return cloned, nil
|
|
}
|
|
|
|
func cloneChallengeConfirmation(value challenge.Confirmation) (challenge.Confirmation, error) {
|
|
cloned := value
|
|
|
|
if value.ClientPublicKey.IsZero() {
|
|
cloned.ClientPublicKey = common.ClientPublicKey{}
|
|
return cloned, nil
|
|
}
|
|
|
|
key, err := common.NewClientPublicKey(value.ClientPublicKey.PublicKey())
|
|
if err != nil {
|
|
return challenge.Confirmation{}, fmt.Errorf("clone challenge confirmation client public key: %w", err)
|
|
}
|
|
cloned.ClientPublicKey = key
|
|
|
|
return cloned, nil
|
|
}
|
|
|
|
func cloneAbuseMetadata(value challenge.AbuseMetadata) challenge.AbuseMetadata {
|
|
cloned := value
|
|
if value.LastAttemptAt != nil {
|
|
lastAttemptAt := *value.LastAttemptAt
|
|
cloned.LastAttemptAt = &lastAttemptAt
|
|
}
|
|
|
|
return cloned
|
|
}
|
|
|
|
func cloneSession(record devicesession.Session) (devicesession.Session, error) {
|
|
cloned := record
|
|
|
|
if !record.ClientPublicKey.IsZero() {
|
|
key, err := common.NewClientPublicKey(record.ClientPublicKey.PublicKey())
|
|
if err != nil {
|
|
return devicesession.Session{}, fmt.Errorf("clone session client public key: %w", err)
|
|
}
|
|
cloned.ClientPublicKey = key
|
|
}
|
|
if record.Revocation != nil {
|
|
revocation := *record.Revocation
|
|
cloned.Revocation = &revocation
|
|
}
|
|
|
|
return cloned, nil
|
|
}
|
|
|
|
func cloneSessions(records []devicesession.Session) ([]devicesession.Session, error) {
|
|
cloned := make([]devicesession.Session, 0, len(records))
|
|
for _, record := range records {
|
|
session, err := cloneSession(record)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
cloned = append(cloned, session)
|
|
}
|
|
|
|
return cloned, nil
|
|
}
|
|
|
|
func cloneProjectionSnapshot(snapshot gatewayprojection.Snapshot) gatewayprojection.Snapshot {
|
|
cloned := snapshot
|
|
if snapshot.RevokedAt != nil {
|
|
revokedAt := *snapshot.RevokedAt
|
|
cloned.RevokedAt = &revokedAt
|
|
}
|
|
|
|
return cloned
|
|
}
|
|
|
|
func sortSessionsNewestFirst(records []devicesession.Session) {
|
|
slices.SortFunc(records, func(left devicesession.Session, right devicesession.Session) int {
|
|
switch {
|
|
case left.CreatedAt.Equal(right.CreatedAt):
|
|
return compareStrings(left.ID.String(), right.ID.String())
|
|
case left.CreatedAt.After(right.CreatedAt):
|
|
return -1
|
|
default:
|
|
return 1
|
|
}
|
|
})
|
|
}
|
|
|
|
func compareStrings(left string, right string) int {
|
|
switch {
|
|
case left < right:
|
|
return -1
|
|
case left > right:
|
|
return 1
|
|
default:
|
|
return 0
|
|
}
|
|
}
|
|
|
|
func cloneTimePointer(value *time.Time) *time.Time {
|
|
if value == nil {
|
|
return nil
|
|
}
|
|
|
|
cloned := *value
|
|
return &cloned
|
|
}
|