feat: add watch streak miner status
This commit is contained in:
+293
-32
@@ -11,10 +11,17 @@ import (
|
||||
)
|
||||
|
||||
const defaultWatchInterval = 20 * time.Second
|
||||
const (
|
||||
maxWatchedChannels = 2
|
||||
watchStreakMaintenanceLimit = 7 * time.Minute
|
||||
watchStreakRestartThreshold = 30 * time.Minute
|
||||
recentOfflineRestartGuard = time.Minute
|
||||
)
|
||||
|
||||
// Service is the Twitch capability surface the miner needs.
|
||||
type Service interface {
|
||||
LoadChannelPointsContext(context.Context, string) (*twitch.ChannelPointsContext, error)
|
||||
WatchStreak(context.Context, string) (*int, error)
|
||||
ClaimCommunityPoints(context.Context, string, string) error
|
||||
StreamMetadata(context.Context, string) (*twitch.StreamMetadata, error)
|
||||
FetchSpadeURL(context.Context, string) (string, error)
|
||||
@@ -35,14 +42,34 @@ type LogEntry struct {
|
||||
Line string
|
||||
}
|
||||
|
||||
// WatchReason describes why the miner is currently watching a streamer.
|
||||
type WatchReason string
|
||||
|
||||
const (
|
||||
WatchReasonStreak WatchReason = "watchstreak"
|
||||
WatchReasonPoints WatchReason = "points"
|
||||
)
|
||||
|
||||
// StatusEntry is the current miner state for one resolved streamer login.
|
||||
type StatusEntry struct {
|
||||
Login string
|
||||
Watching bool
|
||||
Reason WatchReason
|
||||
WatchedMinutes int
|
||||
WatchStreakMinutes int
|
||||
WatchStreak *int
|
||||
}
|
||||
|
||||
// Manager owns background channel points mining state for the current authenticated user.
|
||||
type Manager struct {
|
||||
ctx context.Context
|
||||
service Service
|
||||
pubsub PubSubSyncer
|
||||
onLog func(LogEntry)
|
||||
onStatus func(StatusEntry)
|
||||
watchInterval time.Duration
|
||||
sleep func(context.Context, time.Duration) error
|
||||
now func() time.Time
|
||||
|
||||
mu sync.Mutex
|
||||
auth *auth.State
|
||||
@@ -64,11 +91,30 @@ type streamerState struct {
|
||||
Metadata *twitch.StreamMetadata
|
||||
LastWatchAt time.Time
|
||||
|
||||
WatchStreak *int
|
||||
WatchStreakMissing bool
|
||||
WatchStreakWatched time.Duration
|
||||
Watched time.Duration
|
||||
CurrentWatchReason WatchReason
|
||||
OnlineAt time.Time
|
||||
OfflineAt time.Time
|
||||
PendingStreamUpAt time.Time
|
||||
CurrentBroadcastID string
|
||||
|
||||
seeded bool
|
||||
seeding bool
|
||||
refreshing bool
|
||||
}
|
||||
|
||||
type watchCandidate struct {
|
||||
configLogin string
|
||||
login string
|
||||
channelID string
|
||||
spadeURL string
|
||||
metadata *twitch.StreamMetadata
|
||||
reason WatchReason
|
||||
}
|
||||
|
||||
// NewManager constructs one background miner manager.
|
||||
func NewManager(ctx context.Context, service Service, pubsub PubSubSyncer, onLog func(LogEntry)) *Manager {
|
||||
manager := &Manager{
|
||||
@@ -78,6 +124,7 @@ func NewManager(ctx context.Context, service Service, pubsub PubSubSyncer, onLog
|
||||
onLog: onLog,
|
||||
watchInterval: defaultWatchInterval,
|
||||
sleep: sleepContext,
|
||||
now: time.Now,
|
||||
entries: make(map[string]*streamerState),
|
||||
}
|
||||
if manager.pubsub == nil {
|
||||
@@ -86,6 +133,13 @@ func NewManager(ctx context.Context, service Service, pubsub PubSubSyncer, onLog
|
||||
return manager
|
||||
}
|
||||
|
||||
// SetStatusSink wires a separate miner status callback used by the TUI.
|
||||
func (m *Manager) SetStatusSink(onStatus func(StatusEntry)) {
|
||||
m.mu.Lock()
|
||||
m.onStatus = onStatus
|
||||
m.mu.Unlock()
|
||||
}
|
||||
|
||||
// Sync reconciles the miner against the current resolved streamer snapshot.
|
||||
func (m *Manager) Sync(ctx context.Context, state *auth.State, viewer *twitch.Viewer, entries []twitch.StreamerEntry) {
|
||||
if state == nil || viewer == nil {
|
||||
@@ -99,6 +153,7 @@ func (m *Manager) Sync(ctx context.Context, state *auth.State, viewer *twitch.Vi
|
||||
var (
|
||||
channelIDs []string
|
||||
seedList []seedTarget
|
||||
statuses []StatusEntry
|
||||
)
|
||||
|
||||
m.mu.Lock()
|
||||
@@ -127,13 +182,25 @@ func (m *Manager) Sync(ctx context.Context, state *auth.State, viewer *twitch.Vi
|
||||
current.ConfigLogin = entry.ConfigLogin
|
||||
current.Login = entry.Login
|
||||
current.ChannelID = entry.ChannelID
|
||||
current.Live = entry.Live
|
||||
current.WatchStreak = cloneInt(entry.WatchStreak)
|
||||
now := m.now()
|
||||
switch {
|
||||
case entry.Live && !current.Live:
|
||||
m.markOnlineConfirmedLocked(current, now, entry.WatchStreak)
|
||||
statuses = append(statuses, statusFromState(*current))
|
||||
case !entry.Live && current.Live:
|
||||
m.markOfflineLocked(current, now)
|
||||
statuses = append(statuses, statusFromState(*current))
|
||||
default:
|
||||
current.Live = entry.Live
|
||||
}
|
||||
nextEntries[entry.ConfigLogin] = current
|
||||
}
|
||||
|
||||
m.entries = nextEntries
|
||||
m.startWatchLoopLocked()
|
||||
m.mu.Unlock()
|
||||
m.emitStatuses(statuses)
|
||||
|
||||
_ = m.pubsub.Sync(ctx, viewer.ID, state.AccessToken, channelIDs)
|
||||
for _, target := range seedList {
|
||||
@@ -245,6 +312,7 @@ func (m *Manager) scheduleRefresh(configLogin string) {
|
||||
if current, ok := m.entries[configLogin]; ok && current.ChannelID == channelID {
|
||||
current.SpadeURL = spadeURL
|
||||
current.Metadata = metadata
|
||||
current.CurrentBroadcastID = metadata.BroadcastID
|
||||
current.Live = true
|
||||
}
|
||||
m.mu.Unlock()
|
||||
@@ -274,34 +342,12 @@ func (m *Manager) watchLoop(ctx context.Context) {
|
||||
}
|
||||
|
||||
func (m *Manager) watchOnce(ctx context.Context) error {
|
||||
type candidate struct {
|
||||
configLogin string
|
||||
login string
|
||||
channelID string
|
||||
spadeURL string
|
||||
metadata *twitch.StreamMetadata
|
||||
}
|
||||
|
||||
m.mu.Lock()
|
||||
viewer := m.viewer
|
||||
candidates := make([]candidate, 0, 2)
|
||||
for _, configLogin := range m.order {
|
||||
state, ok := m.entries[configLogin]
|
||||
if !ok || !state.Live || state.Login == "" || state.ChannelID == "" {
|
||||
continue
|
||||
}
|
||||
candidates = append(candidates, candidate{
|
||||
configLogin: configLogin,
|
||||
login: state.Login,
|
||||
channelID: state.ChannelID,
|
||||
spadeURL: state.SpadeURL,
|
||||
metadata: state.Metadata,
|
||||
})
|
||||
if len(candidates) == 2 {
|
||||
break
|
||||
}
|
||||
}
|
||||
candidates := m.watchCandidatesLocked()
|
||||
statuses := m.updateWatchReasonsLocked(candidates)
|
||||
m.mu.Unlock()
|
||||
m.emitStatuses(statuses)
|
||||
|
||||
if viewer == nil || len(candidates) == 0 {
|
||||
return nil
|
||||
@@ -330,14 +376,181 @@ func (m *Manager) watchOnce(ctx context.Context) error {
|
||||
}
|
||||
|
||||
m.mu.Lock()
|
||||
statuses := []StatusEntry{}
|
||||
if state, ok := m.entries[candidate.configLogin]; ok && state.ChannelID == candidate.channelID {
|
||||
state.LastWatchAt = time.Now()
|
||||
state.LastWatchAt = m.now()
|
||||
state.Watched += time.Minute
|
||||
if candidate.reason == WatchReasonStreak && state.WatchStreakMissing {
|
||||
state.WatchStreakWatched += time.Minute
|
||||
if state.WatchStreakWatched >= watchStreakMaintenanceLimit {
|
||||
state.WatchStreakMissing = false
|
||||
state.CurrentWatchReason = WatchReasonPoints
|
||||
}
|
||||
}
|
||||
statuses = append(statuses, statusFromState(*state))
|
||||
}
|
||||
m.mu.Unlock()
|
||||
m.emitStatuses(statuses)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *Manager) watchCandidatesLocked() []watchCandidate {
|
||||
selected := make([]watchCandidate, 0, maxWatchedChannels)
|
||||
seen := make(map[string]bool)
|
||||
for _, configLogin := range m.order {
|
||||
if len(selected) == maxWatchedChannels {
|
||||
break
|
||||
}
|
||||
state, ok := m.entries[configLogin]
|
||||
if !ok || !state.eligibleForStreakWatch() {
|
||||
continue
|
||||
}
|
||||
selected = append(selected, watchCandidateFromState(*state, WatchReasonStreak))
|
||||
seen[configLogin] = true
|
||||
}
|
||||
|
||||
for _, configLogin := range m.order {
|
||||
if len(selected) == maxWatchedChannels {
|
||||
break
|
||||
}
|
||||
if seen[configLogin] {
|
||||
continue
|
||||
}
|
||||
state, ok := m.entries[configLogin]
|
||||
if !ok || !state.eligibleForWatch() {
|
||||
continue
|
||||
}
|
||||
selected = append(selected, watchCandidateFromState(*state, WatchReasonPoints))
|
||||
seen[configLogin] = true
|
||||
}
|
||||
return selected
|
||||
}
|
||||
|
||||
func watchCandidateFromState(state streamerState, reason WatchReason) watchCandidate {
|
||||
return watchCandidate{
|
||||
configLogin: state.ConfigLogin,
|
||||
login: state.Login,
|
||||
channelID: state.ChannelID,
|
||||
spadeURL: state.SpadeURL,
|
||||
metadata: state.Metadata,
|
||||
reason: reason,
|
||||
}
|
||||
}
|
||||
|
||||
func (s streamerState) eligibleForWatch() bool {
|
||||
return s.Live && s.Login != "" && s.ChannelID != ""
|
||||
}
|
||||
|
||||
func (s streamerState) eligibleForStreakWatch() bool {
|
||||
if !s.eligibleForWatch() || !s.WatchStreakMissing || s.WatchStreakWatched >= watchStreakMaintenanceLimit {
|
||||
return false
|
||||
}
|
||||
if s.OfflineAt.IsZero() {
|
||||
return true
|
||||
}
|
||||
return !s.OnlineAt.IsZero() && s.OnlineAt.Sub(s.OfflineAt) > watchStreakRestartThreshold
|
||||
}
|
||||
|
||||
func (m *Manager) updateWatchReasonsLocked(candidates []watchCandidate) []StatusEntry {
|
||||
reasons := make(map[string]WatchReason, len(candidates))
|
||||
for _, candidate := range candidates {
|
||||
reasons[candidate.configLogin] = candidate.reason
|
||||
}
|
||||
|
||||
statuses := make([]StatusEntry, 0, len(m.entries))
|
||||
for configLogin, state := range m.entries {
|
||||
nextReason := reasons[configLogin]
|
||||
if !state.Live {
|
||||
nextReason = ""
|
||||
}
|
||||
if state.CurrentWatchReason == nextReason {
|
||||
continue
|
||||
}
|
||||
state.CurrentWatchReason = nextReason
|
||||
statuses = append(statuses, statusFromState(*state))
|
||||
}
|
||||
return statuses
|
||||
}
|
||||
|
||||
func (m *Manager) markOnlineConfirmedLocked(state *streamerState, now time.Time, watchStreak *int) {
|
||||
state.Live = true
|
||||
state.PendingStreamUpAt = time.Time{}
|
||||
if watchStreak != nil {
|
||||
state.WatchStreak = cloneInt(watchStreak)
|
||||
}
|
||||
if !state.OfflineAt.IsZero() && now.Sub(state.OfflineAt) < recentOfflineRestartGuard {
|
||||
return
|
||||
}
|
||||
state.OnlineAt = now
|
||||
state.WatchStreakMissing = true
|
||||
state.WatchStreakWatched = 0
|
||||
state.SpadeURL = ""
|
||||
state.Metadata = nil
|
||||
state.CurrentBroadcastID = ""
|
||||
}
|
||||
|
||||
func (m *Manager) markOfflineLocked(state *streamerState, now time.Time) {
|
||||
state.Live = false
|
||||
state.OfflineAt = now
|
||||
state.SpadeURL = ""
|
||||
state.Metadata = nil
|
||||
state.Watched = 0
|
||||
state.CurrentWatchReason = ""
|
||||
state.PendingStreamUpAt = time.Time{}
|
||||
state.CurrentBroadcastID = ""
|
||||
}
|
||||
|
||||
func (m *Manager) emitStatusForConfig(configLogin string) {
|
||||
m.mu.Lock()
|
||||
var (
|
||||
status StatusEntry
|
||||
ok bool
|
||||
)
|
||||
if state, found := m.entries[configLogin]; found {
|
||||
status = statusFromState(*state)
|
||||
ok = true
|
||||
}
|
||||
m.mu.Unlock()
|
||||
if ok {
|
||||
m.emitStatuses([]StatusEntry{status})
|
||||
}
|
||||
}
|
||||
|
||||
func (m *Manager) emitStatuses(statuses []StatusEntry) {
|
||||
if len(statuses) == 0 {
|
||||
return
|
||||
}
|
||||
m.mu.Lock()
|
||||
onStatus := m.onStatus
|
||||
m.mu.Unlock()
|
||||
if onStatus == nil {
|
||||
return
|
||||
}
|
||||
for _, status := range statuses {
|
||||
onStatus(status)
|
||||
}
|
||||
}
|
||||
|
||||
func statusFromState(state streamerState) StatusEntry {
|
||||
return StatusEntry{
|
||||
Login: state.Login,
|
||||
Watching: state.Live && state.CurrentWatchReason != "",
|
||||
Reason: state.CurrentWatchReason,
|
||||
WatchedMinutes: int(state.Watched / time.Minute),
|
||||
WatchStreakMinutes: int(state.WatchStreakWatched / time.Minute),
|
||||
WatchStreak: cloneInt(state.WatchStreak),
|
||||
}
|
||||
}
|
||||
|
||||
func cloneInt(value *int) *int {
|
||||
if value == nil {
|
||||
return nil
|
||||
}
|
||||
copy := *value
|
||||
return ©
|
||||
}
|
||||
|
||||
func (m *Manager) handlePubSubEvent(event Event) {
|
||||
configLogin, state := m.streamerForChannel(event.ChannelID)
|
||||
if state == nil {
|
||||
@@ -351,8 +564,18 @@ func (m *Manager) handlePubSubEvent(event Event) {
|
||||
m.mu.Lock()
|
||||
if current, ok := m.entries[configLogin]; ok {
|
||||
current.ChannelPoints = event.Balance
|
||||
if event.ReasonCode == "WATCH_STREAK" {
|
||||
current.WatchStreakMissing = false
|
||||
if current.CurrentWatchReason == WatchReasonStreak {
|
||||
current.CurrentWatchReason = WatchReasonPoints
|
||||
}
|
||||
}
|
||||
}
|
||||
m.mu.Unlock()
|
||||
if event.ReasonCode == "WATCH_STREAK" {
|
||||
m.emitStatusForConfig(configLogin)
|
||||
m.scheduleWatchStreakRefresh(configLogin)
|
||||
}
|
||||
case "claim-available":
|
||||
if event.ClaimID != "" {
|
||||
m.logf(state.Login, "claiming bonus chest: %s", event.ClaimID)
|
||||
@@ -363,28 +586,66 @@ func (m *Manager) handlePubSubEvent(event Event) {
|
||||
case "stream-up":
|
||||
m.mu.Lock()
|
||||
if current, ok := m.entries[configLogin]; ok {
|
||||
current.Live = true
|
||||
current.PendingStreamUpAt = m.now()
|
||||
}
|
||||
m.mu.Unlock()
|
||||
m.scheduleRefresh(configLogin)
|
||||
case "stream-down":
|
||||
var statuses []StatusEntry
|
||||
m.mu.Lock()
|
||||
if current, ok := m.entries[configLogin]; ok {
|
||||
current.Live = false
|
||||
m.markOfflineLocked(current, m.now())
|
||||
statuses = append(statuses, statusFromState(*current))
|
||||
}
|
||||
m.mu.Unlock()
|
||||
m.emitStatuses(statuses)
|
||||
case "viewcount":
|
||||
if !state.Live {
|
||||
var (
|
||||
statuses []StatusEntry
|
||||
shouldRefresh bool
|
||||
)
|
||||
m.mu.Lock()
|
||||
if current, ok := m.entries[configLogin]; ok {
|
||||
current.Live = true
|
||||
m.markOnlineConfirmedLocked(current, m.now(), nil)
|
||||
statuses = append(statuses, statusFromState(*current))
|
||||
shouldRefresh = current.Live
|
||||
}
|
||||
m.mu.Unlock()
|
||||
m.scheduleRefresh(configLogin)
|
||||
m.emitStatuses(statuses)
|
||||
if shouldRefresh {
|
||||
m.scheduleRefresh(configLogin)
|
||||
m.scheduleWatchStreakRefresh(configLogin)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (m *Manager) scheduleWatchStreakRefresh(configLogin string) {
|
||||
m.mu.Lock()
|
||||
state, ok := m.entries[configLogin]
|
||||
if !ok {
|
||||
m.mu.Unlock()
|
||||
return
|
||||
}
|
||||
login := state.Login
|
||||
channelID := state.ChannelID
|
||||
m.mu.Unlock()
|
||||
|
||||
go func() {
|
||||
streak, err := m.service.WatchStreak(m.ctx, login)
|
||||
if err != nil {
|
||||
m.logf(login, "watch streak refresh failed: %v", err)
|
||||
return
|
||||
}
|
||||
m.mu.Lock()
|
||||
if current, ok := m.entries[configLogin]; ok && current.ChannelID == channelID {
|
||||
current.WatchStreak = cloneInt(streak)
|
||||
}
|
||||
m.mu.Unlock()
|
||||
m.emitStatusForConfig(configLogin)
|
||||
}()
|
||||
}
|
||||
|
||||
func (m *Manager) logEvent(login string, event Event) {
|
||||
switch event.MessageType {
|
||||
case "points-earned":
|
||||
|
||||
@@ -15,7 +15,9 @@ type fakeService struct {
|
||||
channelPoints map[string]*twitch.ChannelPointsContext
|
||||
metadata map[string]*twitch.StreamMetadata
|
||||
spadeURLs map[string]string
|
||||
watchStreaks map[string]int
|
||||
playbackErr map[string]error
|
||||
minuteErr map[string]error
|
||||
claimErr map[string]error
|
||||
|
||||
claimed []string
|
||||
@@ -30,6 +32,16 @@ func (f *fakeService) LoadChannelPointsContext(_ context.Context, login string)
|
||||
return nil, errors.New("missing channel points")
|
||||
}
|
||||
|
||||
func (f *fakeService) WatchStreak(_ context.Context, login string) (*int, error) {
|
||||
if f.watchStreaks != nil {
|
||||
if value, ok := f.watchStreaks[login]; ok {
|
||||
return &value, nil
|
||||
}
|
||||
}
|
||||
value := 0
|
||||
return &value, nil
|
||||
}
|
||||
|
||||
func (f *fakeService) ClaimCommunityPoints(_ context.Context, channelID, claimID string) error {
|
||||
f.claimed = append(f.claimed, channelID+":"+claimID)
|
||||
if err, ok := f.claimErr[channelID+":"+claimID]; ok {
|
||||
@@ -67,6 +79,9 @@ func (f *fakeService) TouchPlayback(_ context.Context, login string, _ *twitch.P
|
||||
|
||||
func (f *fakeService) SendMinuteWatched(_ context.Context, spadeURL string, _ twitch.MinuteWatchedPayload) error {
|
||||
f.watched = append(f.watched, "post:"+spadeURL)
|
||||
if err, ok := f.minuteErr[spadeURL]; ok {
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
@@ -158,6 +173,287 @@ func TestManagerWatchOnceUsesTopTwoLiveStreamers(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
func TestManagerWatchOncePrioritizesMissingWatchStreaks(t *testing.T) {
|
||||
service := readyWatchService("alpha_live", "beta_live", "gamma_live")
|
||||
manager := NewManager(context.Background(), service, &fakePubSub{}, nil)
|
||||
defer manager.Close()
|
||||
manager.viewer = &twitch.Viewer{ID: "viewer"}
|
||||
manager.order = []string{"alpha", "beta", "gamma"}
|
||||
manager.entries = map[string]*streamerState{
|
||||
"alpha": readyState("alpha", "alpha_live", "1", false),
|
||||
"beta": readyState("beta", "beta_live", "2", true),
|
||||
"gamma": readyState("gamma", "gamma_live", "3", true),
|
||||
}
|
||||
|
||||
if err := manager.watchOnce(context.Background()); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
if got, want := service.watched, []string{
|
||||
"touch:beta_live",
|
||||
"post:https://spade.test/beta_live",
|
||||
"touch:gamma_live",
|
||||
"post:https://spade.test/gamma_live",
|
||||
}; !reflect.DeepEqual(got, want) {
|
||||
t.Fatalf("watched = %#v, want %#v", got, want)
|
||||
}
|
||||
}
|
||||
|
||||
func TestManagerWatchOnceFillsWithPointsCandidates(t *testing.T) {
|
||||
service := readyWatchService("alpha_live", "beta_live", "gamma_live")
|
||||
manager := NewManager(context.Background(), service, &fakePubSub{}, nil)
|
||||
defer manager.Close()
|
||||
manager.viewer = &twitch.Viewer{ID: "viewer"}
|
||||
manager.order = []string{"alpha", "beta", "gamma"}
|
||||
manager.entries = map[string]*streamerState{
|
||||
"alpha": readyState("alpha", "alpha_live", "1", false),
|
||||
"beta": readyState("beta", "beta_live", "2", true),
|
||||
"gamma": readyState("gamma", "gamma_live", "3", false),
|
||||
}
|
||||
|
||||
if err := manager.watchOnce(context.Background()); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
if got, want := service.watched, []string{
|
||||
"touch:beta_live",
|
||||
"post:https://spade.test/beta_live",
|
||||
"touch:alpha_live",
|
||||
"post:https://spade.test/alpha_live",
|
||||
}; !reflect.DeepEqual(got, want) {
|
||||
t.Fatalf("watched = %#v, want %#v", got, want)
|
||||
}
|
||||
if manager.entries["beta"].CurrentWatchReason != WatchReasonStreak {
|
||||
t.Fatalf("beta reason = %q, want streak", manager.entries["beta"].CurrentWatchReason)
|
||||
}
|
||||
if manager.entries["alpha"].CurrentWatchReason != WatchReasonPoints {
|
||||
t.Fatalf("alpha reason = %q, want points", manager.entries["alpha"].CurrentWatchReason)
|
||||
}
|
||||
}
|
||||
|
||||
func TestManagerStopsWatchStreakMaintenanceAfterSevenMinutes(t *testing.T) {
|
||||
service := readyWatchService("alpha_live")
|
||||
manager := NewManager(context.Background(), service, &fakePubSub{}, nil)
|
||||
defer manager.Close()
|
||||
manager.viewer = &twitch.Viewer{ID: "viewer"}
|
||||
manager.order = []string{"alpha"}
|
||||
manager.entries = map[string]*streamerState{
|
||||
"alpha": readyState("alpha", "alpha_live", "1", true),
|
||||
}
|
||||
|
||||
for i := 0; i < 7; i++ {
|
||||
if err := manager.watchOnce(context.Background()); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
|
||||
state := manager.entries["alpha"]
|
||||
if state.WatchStreakMissing {
|
||||
t.Fatal("expected watch streak maintenance to stop")
|
||||
}
|
||||
if state.WatchStreakWatched != watchStreakMaintenanceLimit {
|
||||
t.Fatalf("watched streak duration = %s, want %s", state.WatchStreakWatched, watchStreakMaintenanceLimit)
|
||||
}
|
||||
if state.Watched != watchStreakMaintenanceLimit {
|
||||
t.Fatalf("watched duration = %s, want %s", state.Watched, watchStreakMaintenanceLimit)
|
||||
}
|
||||
if state.CurrentWatchReason != WatchReasonPoints {
|
||||
t.Fatalf("watch reason = %q, want points", state.CurrentWatchReason)
|
||||
}
|
||||
}
|
||||
|
||||
func TestManagerTracksSuccessfulWatchedMinutesAndResetsOffline(t *testing.T) {
|
||||
service := readyWatchService("alpha_live")
|
||||
manager := NewManager(context.Background(), service, &fakePubSub{}, nil)
|
||||
defer manager.Close()
|
||||
manager.viewer = &twitch.Viewer{ID: "viewer"}
|
||||
manager.order = []string{"alpha"}
|
||||
manager.entries = map[string]*streamerState{
|
||||
"alpha": readyState("alpha", "alpha_live", "1", false),
|
||||
}
|
||||
|
||||
if err := manager.watchOnce(context.Background()); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := manager.watchOnce(context.Background()); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
state := manager.entries["alpha"]
|
||||
if state.Watched != 2*time.Minute {
|
||||
t.Fatalf("watched duration = %s, want 2m", state.Watched)
|
||||
}
|
||||
status := statusFromState(*state)
|
||||
if status.WatchedMinutes != 2 {
|
||||
t.Fatalf("status watched minutes = %d, want 2", status.WatchedMinutes)
|
||||
}
|
||||
|
||||
manager.handlePubSubEvent(Event{MessageType: "stream-down", ChannelID: "1", Timestamp: "down", Topic: "video-playback-by-id"})
|
||||
|
||||
state = manager.entries["alpha"]
|
||||
if state.Watched != 0 {
|
||||
t.Fatalf("watched duration after offline = %s, want 0", state.Watched)
|
||||
}
|
||||
status = statusFromState(*state)
|
||||
if status.Watching || status.WatchedMinutes != 0 {
|
||||
t.Fatalf("status after offline = %#v, want not watching with 0 watched minutes", status)
|
||||
}
|
||||
}
|
||||
|
||||
func TestManagerDoesNotTrackWatchedMinutesWhenTelemetryFails(t *testing.T) {
|
||||
service := readyWatchService("alpha_live")
|
||||
service.minuteErr = map[string]error{
|
||||
"https://spade.test/alpha_live": errors.New("minute rejected"),
|
||||
}
|
||||
manager := NewManager(context.Background(), service, &fakePubSub{}, nil)
|
||||
defer manager.Close()
|
||||
manager.viewer = &twitch.Viewer{ID: "viewer"}
|
||||
manager.order = []string{"alpha"}
|
||||
manager.entries = map[string]*streamerState{
|
||||
"alpha": readyState("alpha", "alpha_live", "1", false),
|
||||
}
|
||||
|
||||
if err := manager.watchOnce(context.Background()); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
if state := manager.entries["alpha"]; state.Watched != 0 {
|
||||
t.Fatalf("watched duration = %s, want 0 after failed telemetry", state.Watched)
|
||||
}
|
||||
}
|
||||
|
||||
func TestHandlePubSubWatchStreakCompletesMaintenance(t *testing.T) {
|
||||
service := &fakeService{watchStreaks: map[string]int{"alpha_live": 8}}
|
||||
manager := NewManager(context.Background(), service, &fakePubSub{}, nil)
|
||||
defer manager.Close()
|
||||
manager.entries["alpha"] = &streamerState{
|
||||
ConfigLogin: "alpha",
|
||||
ChannelID: "1",
|
||||
Login: "alpha_live",
|
||||
Live: true,
|
||||
WatchStreakMissing: true,
|
||||
CurrentWatchReason: WatchReasonStreak,
|
||||
}
|
||||
|
||||
manager.handlePubSubEvent(Event{MessageType: "points-earned", ChannelID: "1", Balance: 555, ReasonCode: "WATCH_STREAK", TotalPoints: 450, Timestamp: "t1", Topic: "community-points-user-v1"})
|
||||
|
||||
waitFor(t, func() bool {
|
||||
manager.mu.Lock()
|
||||
defer manager.mu.Unlock()
|
||||
state := manager.entries["alpha"]
|
||||
return !state.WatchStreakMissing && state.CurrentWatchReason == WatchReasonPoints && state.WatchStreak != nil && *state.WatchStreak == 8
|
||||
})
|
||||
}
|
||||
|
||||
func TestManagerLifecycleResetsWatchStreakOnConfirmedOnline(t *testing.T) {
|
||||
service := &fakeService{}
|
||||
now := time.Date(2026, 4, 30, 12, 0, 0, 0, time.UTC)
|
||||
manager := NewManager(context.Background(), service, &fakePubSub{}, nil)
|
||||
defer manager.Close()
|
||||
manager.now = func() time.Time { return now }
|
||||
manager.entries["alpha"] = &streamerState{
|
||||
ConfigLogin: "alpha",
|
||||
ChannelID: "1",
|
||||
Login: "alpha_live",
|
||||
Live: true,
|
||||
WatchStreakMissing: false,
|
||||
WatchStreakWatched: 5 * time.Minute,
|
||||
SpadeURL: "https://spade.test/alpha",
|
||||
Metadata: &twitch.StreamMetadata{BroadcastID: "old"},
|
||||
}
|
||||
|
||||
manager.handlePubSubEvent(Event{MessageType: "stream-down", ChannelID: "1", Timestamp: "down", Topic: "video-playback-by-id"})
|
||||
now = now.Add(31 * time.Minute)
|
||||
manager.handlePubSubEvent(Event{MessageType: "viewcount", ChannelID: "1", Timestamp: "viewcount", Topic: "video-playback-by-id"})
|
||||
|
||||
manager.mu.Lock()
|
||||
defer manager.mu.Unlock()
|
||||
state := manager.entries["alpha"]
|
||||
if !state.Live || !state.WatchStreakMissing || state.WatchStreakWatched != 0 {
|
||||
t.Fatalf("state = %#v, want fresh live streak maintenance", state)
|
||||
}
|
||||
if state.SpadeURL != "" || state.Metadata != nil {
|
||||
t.Fatalf("playback metadata was not cleared: %#v", state)
|
||||
}
|
||||
}
|
||||
|
||||
func TestManagerLifecycleRecentOfflineGuardPreservesStreakState(t *testing.T) {
|
||||
now := time.Date(2026, 4, 30, 12, 0, 0, 0, time.UTC)
|
||||
manager := NewManager(context.Background(), &fakeService{}, &fakePubSub{}, nil)
|
||||
defer manager.Close()
|
||||
manager.now = func() time.Time { return now }
|
||||
manager.entries["alpha"] = &streamerState{
|
||||
ConfigLogin: "alpha",
|
||||
ChannelID: "1",
|
||||
Login: "alpha_live",
|
||||
Live: false,
|
||||
OfflineAt: now.Add(-30 * time.Second),
|
||||
WatchStreakMissing: false,
|
||||
WatchStreakWatched: 5 * time.Minute,
|
||||
}
|
||||
|
||||
manager.handlePubSubEvent(Event{MessageType: "viewcount", ChannelID: "1", Timestamp: "viewcount", Topic: "video-playback-by-id"})
|
||||
|
||||
manager.mu.Lock()
|
||||
defer manager.mu.Unlock()
|
||||
state := manager.entries["alpha"]
|
||||
if !state.Live {
|
||||
t.Fatal("expected channel to be live after viewcount")
|
||||
}
|
||||
if state.WatchStreakMissing || state.WatchStreakWatched != 5*time.Minute {
|
||||
t.Fatalf("state = %#v, want recent offline guard to preserve streak state", state)
|
||||
}
|
||||
}
|
||||
|
||||
func TestManagerSyncPollingConfirmedOnlineResetsStreakState(t *testing.T) {
|
||||
now := time.Date(2026, 4, 30, 12, 0, 0, 0, time.UTC)
|
||||
manager := NewManager(context.Background(), &fakeService{}, &fakePubSub{}, nil)
|
||||
defer manager.Close()
|
||||
manager.sleep = cancelSleep
|
||||
manager.now = func() time.Time { return now }
|
||||
manager.entries["alpha"] = &streamerState{
|
||||
ConfigLogin: "alpha",
|
||||
ChannelID: "1",
|
||||
Login: "alpha_live",
|
||||
Live: false,
|
||||
OfflineAt: now.Add(-31 * time.Minute),
|
||||
WatchStreakMissing: false,
|
||||
WatchStreakWatched: 5 * time.Minute,
|
||||
}
|
||||
streak := 9
|
||||
|
||||
manager.Sync(context.Background(), &auth.State{AccessToken: "token"}, &twitch.Viewer{ID: "viewer"}, []twitch.StreamerEntry{
|
||||
{ConfigLogin: "alpha", Login: "alpha_live", ChannelID: "1", Live: true, Status: twitch.StreamerReady, WatchStreak: &streak},
|
||||
})
|
||||
|
||||
manager.mu.Lock()
|
||||
defer manager.mu.Unlock()
|
||||
state := manager.entries["alpha"]
|
||||
if !state.Live || !state.WatchStreakMissing || state.WatchStreakWatched != 0 || state.WatchStreak == nil || *state.WatchStreak != 9 {
|
||||
t.Fatalf("state = %#v, want polling-confirmed fresh live streak state", state)
|
||||
}
|
||||
}
|
||||
|
||||
func TestManagerStreamUpWaitsForConfirmation(t *testing.T) {
|
||||
now := time.Date(2026, 4, 30, 12, 0, 0, 0, time.UTC)
|
||||
manager := NewManager(context.Background(), &fakeService{}, &fakePubSub{}, nil)
|
||||
defer manager.Close()
|
||||
manager.now = func() time.Time { return now }
|
||||
manager.entries["alpha"] = &streamerState{ConfigLogin: "alpha", ChannelID: "1", Login: "alpha_live"}
|
||||
|
||||
manager.handlePubSubEvent(Event{MessageType: "stream-up", ChannelID: "1", Timestamp: "up", Topic: "video-playback-by-id"})
|
||||
|
||||
manager.mu.Lock()
|
||||
defer manager.mu.Unlock()
|
||||
state := manager.entries["alpha"]
|
||||
if state.Live {
|
||||
t.Fatal("stream-up should wait for API/viewcount confirmation")
|
||||
}
|
||||
if !state.PendingStreamUpAt.Equal(now) {
|
||||
t.Fatalf("pending stream-up = %s, want %s", state.PendingStreamUpAt, now)
|
||||
}
|
||||
}
|
||||
|
||||
func TestHandlePubSubEventUpdatesBalanceAndClaims(t *testing.T) {
|
||||
service := &fakeService{}
|
||||
manager := NewManager(context.Background(), service, &fakePubSub{}, nil)
|
||||
@@ -205,6 +501,31 @@ func TestManagerLogsPubSubEventsAndFailures(t *testing.T) {
|
||||
|
||||
func cancelSleep(context.Context, time.Duration) error { return context.Canceled }
|
||||
|
||||
func readyWatchService(logins ...string) *fakeService {
|
||||
service := &fakeService{
|
||||
metadata: map[string]*twitch.StreamMetadata{},
|
||||
spadeURLs: map[string]string{},
|
||||
}
|
||||
for _, login := range logins {
|
||||
service.metadata[login] = &twitch.StreamMetadata{BroadcastID: "broadcast-" + login}
|
||||
service.spadeURLs[login] = "https://spade.test/" + login
|
||||
}
|
||||
return service
|
||||
}
|
||||
|
||||
func readyState(configLogin, login, channelID string, missingStreak bool) *streamerState {
|
||||
return &streamerState{
|
||||
ConfigLogin: configLogin,
|
||||
Login: login,
|
||||
ChannelID: channelID,
|
||||
Live: true,
|
||||
SpadeURL: "https://spade.test/" + login,
|
||||
Metadata: &twitch.StreamMetadata{BroadcastID: "broadcast-" + login},
|
||||
WatchStreakMissing: missingStreak,
|
||||
OnlineAt: time.Date(2026, 4, 30, 12, 0, 0, 0, time.UTC),
|
||||
}
|
||||
}
|
||||
|
||||
func waitFor(t *testing.T, condition func() bool) {
|
||||
t.Helper()
|
||||
deadline := time.Now().Add(2 * time.Second)
|
||||
|
||||
@@ -28,6 +28,8 @@ type Event struct {
|
||||
Timestamp string
|
||||
Balance int
|
||||
ClaimID string
|
||||
ReasonCode string
|
||||
TotalPoints int
|
||||
}
|
||||
|
||||
func (e Event) key() string {
|
||||
@@ -291,6 +293,10 @@ func parseFrame(message []byte) (*frame, error) {
|
||||
Balance int `json:"balance"`
|
||||
ChannelID string `json:"channel_id"`
|
||||
} `json:"balance"`
|
||||
PointGain *struct {
|
||||
ReasonCode string `json:"reason_code"`
|
||||
TotalPoints int `json:"total_points"`
|
||||
} `json:"point_gain"`
|
||||
} `json:"data"`
|
||||
}
|
||||
if err := json.Unmarshal([]byte(envelope.Data.Message), &payload); err != nil {
|
||||
@@ -320,6 +326,10 @@ func parseFrame(message []byte) (*frame, error) {
|
||||
if payload.Data.Claim != nil {
|
||||
result.Event.ClaimID = payload.Data.Claim.ID
|
||||
}
|
||||
if payload.Data.PointGain != nil {
|
||||
result.Event.ReasonCode = payload.Data.PointGain.ReasonCode
|
||||
result.Event.TotalPoints = payload.Data.PointGain.TotalPoints
|
||||
}
|
||||
return result, nil
|
||||
}
|
||||
|
||||
|
||||
@@ -14,6 +14,18 @@ func TestParseFramePointsEarned(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
func TestParseFramePointsEarnedPointGain(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
frame, err := parseFrame([]byte(`{"type":"MESSAGE","data":{"topic":"community-points-user-v1.viewer","message":"{\"type\":\"points-earned\",\"data\":{\"timestamp\":\"2026-04-29T12:00:00Z\",\"balance\":{\"balance\":42,\"channel_id\":\"123\"},\"point_gain\":{\"reason_code\":\"WATCH_STREAK\",\"total_points\":450}}}"}}`))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if frame.Event.ReasonCode != "WATCH_STREAK" || frame.Event.TotalPoints != 450 {
|
||||
t.Fatalf("event = %#v", frame.Event)
|
||||
}
|
||||
}
|
||||
|
||||
func TestParseFrameClaimAvailable(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
|
||||
Reference in New Issue
Block a user