livekit-protocol 0.7.9

Livekit protocol and utilities for the Rust SDK
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

package observability

import (
	"testing"
	"time"

	"github.com/stretchr/testify/require"
)

func TestSessionTimer(t *testing.T) {
	t.Run("advance 100ms", func(t *testing.T) {
		ts := time.Now()
		st := NewSessionTimer(ts)

		millis, secs, mins := st.Advance(ts.Add(100 * time.Millisecond))
		require.EqualValues(t, 100, millis)
		require.EqualValues(t, 1, secs)
		require.EqualValues(t, 1, mins)

		millis, secs, mins = st.Advance(ts.Add(200 * time.Millisecond))
		require.EqualValues(t, 100, millis)
		require.EqualValues(t, 0, secs)
		require.EqualValues(t, 0, mins)
	})

	t.Run("advance 2.5m", func(t *testing.T) {
		ts := time.Now()
		st := NewSessionTimer(ts)

		millis, secs, mins := st.Advance(ts.Add(150 * time.Second))
		require.EqualValues(t, 150000, millis)
		require.EqualValues(t, 150, secs)
		require.EqualValues(t, 3, mins)
	})

	t.Run("WithMinSeconds floors first advance and consumes watermark", func(t *testing.T) {
		ts := time.Now()
		st := NewSessionTimer(ts, WithMinSeconds(60))

		_, secs, _ := st.Advance(ts.Add(time.Second))
		require.EqualValues(t, 60, secs)

		_, secs, _ = st.Advance(ts.Add(30 * time.Second))
		require.EqualValues(t, 0, secs)

		_, secs, _ = st.Advance(ts.Add(62 * time.Second))
		require.EqualValues(t, 2, secs)
	})

	t.Run("WithMinSeconds does not lower larger natural value", func(t *testing.T) {
		ts := time.Now()
		st := NewSessionTimer(ts, WithMinSeconds(60))

		_, secs, _ := st.Advance(ts.Add(120 * time.Second))
		require.EqualValues(t, 120, secs)
	})

	t.Run("WithMinSeconds does not trigger on no-op advance", func(t *testing.T) {
		ts := time.Now()
		st := NewSessionTimer(ts, WithMinSeconds(60))

		_, secs, _ := st.Advance(ts)
		require.EqualValues(t, 0, secs)

		_, secs, _ = st.Advance(ts.Add(time.Second))
		require.EqualValues(t, 60, secs)
	})

	t.Run("WithMinMinutes floors first advance", func(t *testing.T) {
		ts := time.Now()
		st := NewSessionTimer(ts, WithMinMinutes(5))

		_, _, mins := st.Advance(ts.Add(time.Second))
		require.EqualValues(t, 5, mins)

		_, _, mins = st.Advance(ts.Add(2 * time.Minute))
		require.EqualValues(t, 0, mins)

		_, _, mins = st.Advance(ts.Add(7 * time.Minute))
		require.EqualValues(t, 2, mins)
	})

	t.Run("WithMinSeconds and WithMinMinutes apply independently", func(t *testing.T) {
		ts := time.Now()
		st := NewSessionTimer(ts, WithMinSeconds(45), WithMinMinutes(3))

		_, secs, mins := st.Advance(ts.Add(time.Second))
		require.EqualValues(t, 45, secs)
		require.EqualValues(t, 3, mins)
	})

	t.Run("Reset re-anchors so pre-reset time is not counted", func(t *testing.T) {
		ts := time.Now()
		st := NewSessionTimer(ts)

		// 90s elapse before the participant actually joins; that time should not
		// be billed once we re-anchor to the join time.
		joinedAt := ts.Add(90 * time.Second)
		st.Reset(joinedAt)

		millis, secs, mins := st.Advance(joinedAt.Add(30 * time.Second))
		require.EqualValues(t, 30000, millis)
		require.EqualValues(t, 30, secs)
		require.EqualValues(t, 1, mins)
	})

	t.Run("Reset preserves min-seconds option", func(t *testing.T) {
		ts := time.Now()
		st := NewSessionTimer(ts, WithMinSeconds(45))

		joinedAt := ts.Add(10 * time.Second)
		st.Reset(joinedAt)

		_, secs, _ := st.Advance(joinedAt.Add(time.Second))
		require.EqualValues(t, 45, secs)
	})
}