w3pilot/clock.go at main · plexusone/w3pilot · GitHub

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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
package w3pilot

import (
	"context"
	"time"
)

// Clock provides control over time in the browser.
type Clock struct {
	client  *BiDiClient
	context string
}

// NewClock creates a new Clock controller.
func NewClock(client *BiDiClient, browsingContext string) *Clock {
	return &Clock{
		client:  client,
		context: browsingContext,
	}
}

// ClockInstallOptions configures clock installation.
type ClockInstallOptions struct {
	// Time to set as the current time (Unix timestamp in milliseconds or time.Time)
	Time interface{}
}

// Install installs fake timers in the browser.
// This replaces native time-related functions like Date, setTimeout, etc.
func (c *Clock) Install(ctx context.Context, opts *ClockInstallOptions) error {
	params := map[string]interface{}{
		"context": c.context,
	}

	if opts != nil && opts.Time != nil {
		switch t := opts.Time.(type) {
		case time.Time:
			params["time"] = t.UnixMilli()
		case int64:
			params["time"] = t
		}
	}

	_, err := c.client.Send(ctx, "vibium:clock.install", params)
	return err
}

// FastForward advances time by the specified number of milliseconds.
// Timers are not fired.
func (c *Clock) FastForward(ctx context.Context, ticks int64) error {
	params := map[string]interface{}{
		"context": c.context,
		"ticks":   ticks,
	}

	_, err := c.client.Send(ctx, "vibium:clock.fastForward", params)
	return err
}

// RunFor advances time by the specified number of milliseconds,
// firing all pending timers.
func (c *Clock) RunFor(ctx context.Context, ticks int64) error {
	params := map[string]interface{}{
		"context": c.context,
		"ticks":   ticks,
	}

	_, err := c.client.Send(ctx, "vibium:clock.runFor", params)
	return err
}

// PauseAt pauses time at the specified timestamp.
func (c *Clock) PauseAt(ctx context.Context, t interface{}) error {
	params := map[string]interface{}{
		"context": c.context,
	}

	switch tv := t.(type) {
	case time.Time:
		params["time"] = tv.UnixMilli()
	case int64:
		params["time"] = tv
	}

	_, err := c.client.Send(ctx, "vibium:clock.pauseAt", params)
	return err
}

// Resume resumes time from a paused state.
func (c *Clock) Resume(ctx context.Context) error {
	params := map[string]interface{}{
		"context": c.context,
	}

	_, err := c.client.Send(ctx, "vibium:clock.resume", params)
	return err
}

// SetFixedTime sets a fixed time that will be returned by Date.now() and new Date().
func (c *Clock) SetFixedTime(ctx context.Context, t interface{}) error {
	params := map[string]interface{}{
		"context": c.context,
	}

	switch tv := t.(type) {
	case time.Time:
		params["time"] = tv.UnixMilli()
	case int64:
		params["time"] = tv
	}

	_, err := c.client.Send(ctx, "vibium:clock.setFixedTime", params)
	return err
}

// SetSystemTime sets the system time.
func (c *Clock) SetSystemTime(ctx context.Context, t interface{}) error {
	params := map[string]interface{}{
		"context": c.context,
	}

	switch tv := t.(type) {
	case time.Time:
		params["time"] = tv.UnixMilli()
	case int64:
		params["time"] = tv
	}

	_, err := c.client.Send(ctx, "vibium:clock.setSystemTime", params)
	return err
}

// SetTimezone sets the timezone.
func (c *Clock) SetTimezone(ctx context.Context, tz string) error {
	params := map[string]interface{}{
		"context":  c.context,
		"timezone": tz,
	}

	_, err := c.client.Send(ctx, "vibium:clock.setTimezone", params)
	return err
}