11627546130

Committed 01 Nov 2024 09:51AM UTC coverage: 80.929% (-0.3%) from 81.231%

Build # 11627546130

Build Type

push

github

Committed by

web-flow

Commit Message

feat: add WebSocket routing (#503)

* feat: add WebSocket routing
* chore: roll to Playwright v1.48.2

Run Details

271 of 357 new or added lines in 11 files covered. (75.91%)

2 existing lines in 2 files now uncovered.

7265 of 8977 relevant lines covered (80.93%)

10837.31 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

93.1

/channel.go

package playwright

import (
        "encoding/json"
        "fmt"
)

type channel struct {
        eventEmitter
        guid       string
        connection *connection
        owner      *channelOwner // to avoid type conversion
        object     interface{}   // retain type info (for fromChannel needed)
}

func (c *channel) MarshalJSON() ([]byte, error) {
        return json.Marshal(map[string]string{
                "guid": c.guid,
        })
}

// for catch errors of route handlers etc.
func (c *channel) CreateTask(fn func()) {
        go func() {
                defer func() {
                        if e := recover(); e != nil {
                                err, ok := e.(error)
                                if ok {
                                        c.connection.err.Set(err)
                                } else {
                                        c.connection.err.Set(fmt.Errorf("%v", e))
                                }
                        }
                }()
                fn()
        }()
}

func (c *channel) Send(method string, options ...interface{}) (interface{}, error) {
        return c.connection.WrapAPICall(func() (interface{}, error) {
                return c.innerSend(method, options...).GetResultValue()
        }, c.owner.isInternalType)
}

func (c *channel) SendReturnAsDict(method string, options ...interface{}) (map[string]interface{}, error) {
        ret, err := c.connection.WrapAPICall(func() (interface{}, error) {
                return c.innerSend(method, options...).GetResult()
        }, c.owner.isInternalType)
        return ret.(map[string]interface{}), err
}

func (c *channel) innerSend(method string, options ...interface{}) *protocolCallback {
        if err := c.connection.err.Get(); err != nil {
                c.connection.err.Set(nil)
                pc := newProtocolCallback(false, c.connection.abort)
                pc.SetError(err)
                return pc
        }
        params := transformOptions(options...)
        return c.connection.sendMessageToServer(c.owner, method, params, false)
}

// SendNoReply ignores return value and errors
// almost equivalent to `send(...).catch(() => {})`
func (c *channel) SendNoReply(method string, options ...interface{}) {
        c.innerSendNoReply(method, c.owner.isInternalType, options...)
}

func (c *channel) SendNoReplyInternal(method string, options ...interface{}) {
        c.innerSendNoReply(method, true, options...)
}

func (c *channel) innerSendNoReply(method string, isInternal bool, options ...interface{}) {
        params := transformOptions(options...)
        _, err := c.connection.WrapAPICall(func() (interface{}, error) {
                return c.connection.sendMessageToServer(c.owner, method, params, true).GetResult()
        }, isInternal)
        if err != nil {
                // ignore error actively, log only for debug
                logger.Printf("SendNoReply failed: %v\n", err)
        }
}

func newChannel(owner *channelOwner, object interface{}) *channel {
        channel := &channel{
                connection: owner.connection,
                guid:       owner.guid,
                owner:      owner,
                object:     object,
        }
        return channel
}

1	package playwright
2
3	import (
4	"encoding/json"
5	"fmt"
6	)
7
8	type channel struct {
9	eventEmitter
10	guid string
11	connection *connection
12	owner *channelOwner // to avoid type conversion
13	object interface{} // retain type info (for fromChannel needed)
14	}
15
16	func (c *channel) MarshalJSON() ([]byte, error) {	431✔
17	return json.Marshal(map[string]string{	431✔
18	"guid": c.guid,	431✔
19	})	431✔
20	}	431✔
21
22	// for catch errors of route handlers etc.
23	func (c *channel) CreateTask(fn func()) {	3,037✔
24	go func() {	6,074✔
25	defer func() {	5,989✔
26	if e := recover(); e != nil {	2,969✔
27	err, ok := e.(error)	17✔
28	if ok {	17✔
NEW 29	c.connection.err.Set(err)	×
30	} else {	17✔
31	c.connection.err.Set(fmt.Errorf("%v", e))	17✔
32	}	17✔
33	}
34	}()
35	fn()	3,037✔
36	}()
37	}
38
39	func (c *channel) Send(method string, options ...interface{}) (interface{}, error) {	93,866✔
40	return c.connection.WrapAPICall(func() (interface{}, error) {	187,732✔
41	return c.innerSend(method, options...).GetResultValue()	93,866✔
42	}, c.owner.isInternalType)	93,866✔
43	}
44
45	func (c *channel) SendReturnAsDict(method string, options ...interface{}) (map[string]interface{}, error) {	6,487✔
46	ret, err := c.connection.WrapAPICall(func() (interface{}, error) {	12,974✔
47	return c.innerSend(method, options...).GetResult()	6,487✔
48	}, c.owner.isInternalType)	6,487✔
49	return ret.(map[string]interface{}), err	6,487✔
50	}
51
52	func (c channel) innerSend(method string, options ...interface{}) protocolCallback {	100,353✔
53	if err := c.connection.err.Get(); err != nil {	100,370✔
54	c.connection.err.Set(nil)	17✔
55	pc := newProtocolCallback(false, c.connection.abort)	17✔
56	pc.SetError(err)	17✔
57	return pc	17✔
58	}	17✔
59	params := transformOptions(options...)	100,336✔
60	return c.connection.sendMessageToServer(c.owner, method, params, false)	100,336✔
61	}
62
63	// SendNoReply ignores return value and errors
64	// almost equivalent to `send(...).catch(() => {})`
65	func (c *channel) SendNoReply(method string, options ...interface{}) {	918✔
66	c.innerSendNoReply(method, c.owner.isInternalType, options...)	918✔
67	}	918✔
68
69	func (c *channel) SendNoReplyInternal(method string, options ...interface{}) {	1,497✔
70	c.innerSendNoReply(method, true, options...)	1,497✔
71	}	1,497✔
72
73	func (c *channel) innerSendNoReply(method string, isInternal bool, options ...interface{}) {	2,415✔
74	params := transformOptions(options...)	2,415✔
75	_, err := c.connection.WrapAPICall(func() (interface{}, error) {	4,830✔
76	return c.connection.sendMessageToServer(c.owner, method, params, true).GetResult()	2,415✔
77	}, isInternal)	2,415✔
78	if err != nil {	2,415✔
NEW 79	// ignore error actively, log only for debug	×
80	logger.Printf("SendNoReply failed: %v\n", err)	×
81	}	×
82	}
83
84	func newChannel(owner channelOwner, object interface{}) channel {	87,106✔
85	channel := &channel{	87,106✔
86	connection: owner.connection,	87,106✔
87	guid: owner.guid,	87,106✔
88	owner: owner,	87,106✔
89	object: object,	87,106✔
90	}	87,106✔
91	return channel	87,106✔
92	}	87,106✔

playwright-community / playwright-go / 11627546130

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous