parasocial
Code Issues

feat: add twitch live detection to streamer list

Browse Source
This commit is contained in:
ruinivist
2026-04-28 23:22:51 +02:00
parent 2f81173f1e
commit 01b044e305
7 changed files with 354 additions and 32 deletions
Download Patch File Download Diff File Expand all files Collapse all files
internal/app/app.go
+70 -20
View File
@@ -21,6 +21,8 @@ import (
"parasocial/internal/twitch"
)
const streamerRefreshInterval = 5 * time.Minute
// Run loads the application configuration and starts the terminal UI.
func Run(ctx context.Context) error {
ctx, cancel := context.WithCancel(ctx)
@@ -97,6 +99,8 @@ func Run(ctx context.Context) error {
type streamerService interface {
CurrentUser(context.Context) (*twitch.Viewer, error)
ResolveStreamer(context.Context, string) (*twitch.Channel, error)
StreamInfo(context.Context, string) (*twitch.StreamInfo, error)
PlaybackAccessToken(context.Context, string) (*twitch.PlaybackToken, error)
}
// newTwitchService builds a Twitch service from the authenticated session state.
@@ -118,36 +122,82 @@ func newTwitchService(httpClient *http.Client, state *auth.State) (*twitch.Servi
// resolveStreamerEntries streams viewer and streamer resolution results into the TUI.
func resolveStreamerEntries(ctx context.Context, service streamerService, logins []string, send func(tui.StreamerUpdate)) error {
return resolveStreamerEntriesWithSleep(ctx, service, logins, send, streamerRefreshInterval, sleepContext)
}
func resolveStreamerEntriesWithSleep(ctx context.Context, service streamerService, logins []string, send func(tui.StreamerUpdate), interval time.Duration, sleep func(context.Context, time.Duration) error) error {
viewer, err := service.CurrentUser(ctx)
if err != nil {
return fmt.Errorf("resolve current user: %w", err)
}
send(tui.StreamerUpdate{Viewer: viewer})
for index, login := range logins {
entry := twitch.StreamerEntry{
ConfigLogin: login,
Status: twitch.StreamerLoading,
for {
for index, login := range logins {
entry, err := resolveStreamerEntry(ctx, service, login)
if errors.Is(err, context.Canceled) {
return err
}
send(tui.StreamerUpdate{
Index: index,
Entry: entry,
})
}
channel, err := service.ResolveStreamer(ctx, login)
switch {
case err == nil:
entry.Login = channel.Login
entry.ChannelID = channel.ID
entry.Status = twitch.StreamerReady
case errors.Is(err, context.Canceled):
if err := sleep(ctx, interval); err != nil {
return err
default:
entry.Status = twitch.StreamerError
entry.Error = err.Error()
}
}
}
send(tui.StreamerUpdate{
Index: index,
Entry: &entry,
})
func resolveStreamerEntry(ctx context.Context, service streamerService, login string) (*twitch.StreamerEntry, error) {
entry := &twitch.StreamerEntry{
ConfigLogin: login,
Status: twitch.StreamerLoading,
}
return nil
channel, err := service.ResolveStreamer(ctx, login)
switch {
case err == nil:
entry.Login = channel.Login
entry.ChannelID = channel.ID
case errors.Is(err, context.Canceled):
return nil, err
default:
entry.Status = twitch.StreamerError
entry.Error = err.Error()
return entry, nil
}
stream, err := service.StreamInfo(ctx, channel.ID)
switch {
case err == nil:
entry.Status = twitch.StreamerReady
entry.Live = stream.Online
case errors.Is(err, context.Canceled):
return nil, err
default:
entry.Status = twitch.StreamerError
entry.Error = err.Error()
return entry, nil
}
if !entry.Live {
return entry, nil
}
if _, err := service.PlaybackAccessToken(ctx, channel.Login); err != nil && errors.Is(err, context.Canceled) {
return nil, err
}
return entry, nil
}
func sleepContext(ctx context.Context, duration time.Duration) error {
timer := time.NewTimer(duration)
defer timer.Stop()
select {
case <-ctx.Done():
return ctx.Err()
case <-timer.C:
return nil
}
}
internal/app/app_test.go
+126 -9
View File
@@ -7,6 +7,7 @@ import (
"context"
"errors"
"testing"
"time"
"parasocial/internal/tui"
"parasocial/internal/twitch"
@@ -14,10 +15,18 @@ import (
// fakeStreamerService is a test double for the app's Twitch resolution dependency.
type fakeStreamerService struct {
viewer *twitch.Viewer
viewerErr error
channels map[string]*twitch.Channel
errs map[string]error
viewer *twitch.Viewer
viewerErr error
channels map[string]*twitch.Channel
resolveErrs map[string]error
streams map[string][]streamResult
streamCalls map[string]int
playbackErr map[string]error
}
type streamResult struct {
info *twitch.StreamInfo
err error
}
// CurrentUser returns the configured fake viewer or viewer error.
@@ -30,12 +39,40 @@ func (f *fakeStreamerService) CurrentUser(context.Context) (*twitch.Viewer, erro
// ResolveStreamer returns the configured fake channel or resolution error.
func (f *fakeStreamerService) ResolveStreamer(_ context.Context, login string) (*twitch.Channel, error) {
if err, ok := f.errs[login]; ok {
if err, ok := f.resolveErrs[login]; ok {
return nil, err
}
return f.channels[login], nil
}
func (f *fakeStreamerService) StreamInfo(_ context.Context, channelID string) (*twitch.StreamInfo, error) {
if f.streamCalls == nil {
f.streamCalls = map[string]int{}
}
call := f.streamCalls[channelID]
f.streamCalls[channelID] = call + 1
results := f.streams[channelID]
if len(results) == 0 {
return &twitch.StreamInfo{Online: false}, nil
}
if call >= len(results) {
call = len(results) - 1
}
result := results[call]
if result.err != nil {
return nil, result.err
}
return result.info, nil
}
func (f *fakeStreamerService) PlaybackAccessToken(_ context.Context, login string) (*twitch.PlaybackToken, error) {
if err, ok := f.playbackErr[login]; ok {
return nil, err
}
return &twitch.PlaybackToken{Signature: "sig", Value: "token"}, nil
}
// TestResolveStreamerEntries verifies that app resolution emits viewer, success, and error updates.
func TestResolveStreamerEntries(t *testing.T) {
t.Parallel()
@@ -45,16 +82,21 @@ func TestResolveStreamerEntries(t *testing.T) {
channels: map[string]*twitch.Channel{
"alpha": {ID: "1", Login: "alpha_live"},
},
errs: map[string]error{
resolveErrs: map[string]error{
"beta": errors.New("lookup failed"),
},
streams: map[string][]streamResult{
"1": {{info: &twitch.StreamInfo{Online: true}}},
},
}
var updates []tui.StreamerUpdate
err := resolveStreamerEntries(context.Background(), service, []string{"alpha", "beta"}, func(update tui.StreamerUpdate) {
err := resolveStreamerEntriesWithSleep(context.Background(), service, []string{"alpha", "beta"}, func(update tui.StreamerUpdate) {
updates = append(updates, update)
}, 0, func(context.Context, time.Duration) error {
return context.Canceled
})
if err != nil {
if !errors.Is(err, context.Canceled) {
t.Fatal(err)
}
if len(updates) != 3 {
@@ -63,10 +105,85 @@ func TestResolveStreamerEntries(t *testing.T) {
if updates[0].Viewer == nil || updates[0].Viewer.Login != "viewer" {
t.Fatalf("viewer update = %#v", updates[0])
}
if updates[1].Entry == nil || updates[1].Entry.Status != twitch.StreamerReady || updates[1].Entry.Login != "alpha_live" {
if updates[1].Entry == nil || updates[1].Entry.Status != twitch.StreamerReady || updates[1].Entry.Login != "alpha_live" || !updates[1].Entry.Live {
t.Fatalf("alpha update = %#v", updates[1])
}
if updates[2].Entry == nil || updates[2].Entry.Status != twitch.StreamerError {
t.Fatalf("beta update = %#v", updates[2])
}
}
func TestResolveStreamerEntriesPlaybackFailureStillMarksLive(t *testing.T) {
t.Parallel()
service := &fakeStreamerService{
viewer: &twitch.Viewer{ID: "7", Login: "viewer"},
channels: map[string]*twitch.Channel{
"alpha": {ID: "1", Login: "alpha_live"},
},
streams: map[string][]streamResult{
"1": {{info: &twitch.StreamInfo{Online: true}}},
},
playbackErr: map[string]error{
"alpha_live": errors.New("token lookup failed"),
},
}
var updates []tui.StreamerUpdate
err := resolveStreamerEntriesWithSleep(context.Background(), service, []string{"alpha"}, func(update tui.StreamerUpdate) {
updates = append(updates, update)
}, 0, func(context.Context, time.Duration) error {
return context.Canceled
})
if !errors.Is(err, context.Canceled) {
t.Fatal(err)
}
if len(updates) != 2 {
t.Fatalf("len(updates) = %d", len(updates))
}
entry := updates[1].Entry
if entry == nil || entry.Status != twitch.StreamerReady || !entry.Live {
t.Fatalf("entry = %#v", entry)
}
}
func TestResolveStreamerEntriesRefreshesLiveState(t *testing.T) {
t.Parallel()
service := &fakeStreamerService{
viewer: &twitch.Viewer{ID: "7", Login: "viewer"},
channels: map[string]*twitch.Channel{
"alpha": {ID: "1", Login: "alpha_live"},
},
streams: map[string][]streamResult{
"1": {
{info: &twitch.StreamInfo{Online: false}},
{info: &twitch.StreamInfo{Online: true}},
},
},
}
var updates []tui.StreamerUpdate
sleepCalls := 0
err := resolveStreamerEntriesWithSleep(context.Background(), service, []string{"alpha"}, func(update tui.StreamerUpdate) {
updates = append(updates, update)
}, 0, func(context.Context, time.Duration) error {
sleepCalls++
if sleepCalls == 1 {
return nil
}
return context.Canceled
})
if !errors.Is(err, context.Canceled) {
t.Fatal(err)
}
if len(updates) != 3 {
t.Fatalf("len(updates) = %d", len(updates))
}
if updates[1].Entry == nil || updates[1].Entry.Live {
t.Fatalf("first pass = %#v", updates[1])
}
if updates[2].Entry == nil || !updates[2].Entry.Live {
t.Fatalf("second pass = %#v", updates[2])
}
}