Skip to content

Conversation

@AndrewSverdrup
Copy link

No description provided.

Let them all follow the same pattern to make things more clear.
The event handlers might provide the needed response right away, before
even existing the event handler. We should be prepared to handle this
case.
This matches the true contents of a WebSocket 'message' event, so should
be a more realistic test.
The given data was not a correct RRE rect.
The "None" authentication will directly progress past authentication, so
it's not a good type for this test.
Spies should just attach without modifying the real method, or we might
get unwanted side effects.
This is not something we intend to implement, so remove this never used
test case.
We should test using only external manipulation so we don't assume a
specific implementation.
Avoid poking around in the internals and instead test things using the
official methods and events. This should give us more realistic and
robust tests.
VeNCrypt is a multiplexer for many authentication methods, not just
Plain. So let's split it to its own section, just like other types.
We should have constants local for the test function when doing
comparisons or we might have false positives because we compare with
buggy values in the code under test.
Stop bypassing the data handling steps in the test as that means those
parts don't get tested.
These test the RFB class, so they should be with all other tests for
that class.
We shouldn't add extra, undocumented, API just for the tests. They need
to figure out less invasive way to probe things.
The code tested here makes heavy use of promises, so it is easier to
test things also using promise centric code.
Make the tests more clear what data is expected in the different stages
of the handshake.
Avoid poking in to internals and instead test that the RFB object
responds correctly to new messages.
This is an internal function so we should not be examining it in the
tests. Instead use the well defined public APIs to check for correct
behaviour.
Tests should avoid poking in to the internals and should only look at
external behaviour.
Avoid poking around in the internals and instead test what is actually
sent out on the WebSocket.
This small object will not properly fake a Websock in more complex
cases, so let's avoid it and create a real Websock instead.
The caller might hang on to the data for multiple calls, so we make sure
the returned buffer might not get overwritten.
All of these functions should have units tests, even if they are fairly
minimal.
Let's test the full final result instead of assuming specific internal
calls.
This is extra important in the tests where we expect no changes to the
display, as otherwise we can't tell the difference between success and a
decoder that is simply waiting for more data.
We don't have to keep track of this much data between rects, so
restructure things to make it more simple. This allows the JPEG parsing
code to be a pure function which only depends on the input.
We don't need any full slice functionality, so let's change this to
better march rQpeek8() and rQshiftBytes().
That is the modern way to handle operations that cannot complete
immediately.
Use proper accessor functions instead of poking around in internal
buffers.
CendioOssman and others added 30 commits September 10, 2025 10:21
This is much more efficient than looking at two bytes at a time.
Our snap packages no longer contain python2-websockify. It's now called
websockify and is found in snap by the WEBSOCKIFY_FROMSYSTEM check.
Our snap package requires bash to run novnc_proxy, but it doesn't
explicitly set a requirement for the which command to be installed.
Let's therefore use a bash built-in when looking for the websockify
binary.
Clipboard permissions must be supported, with states "granted" or
"prompt" for both write and read.
With async clipboard available, the fallback clipboard textarea adds
mostly confusion. If async clipboard is out right denied, users most
likely don't want to see any clipboard activity.
The warning prompt is only displayed if there is an active connected
session, when viewOnly is disabled.
We are using OIDC now instead of the old style access tokens.
Apparently publishing with OIDC as an auth method only works with npm
11.5.1 and onward.
Node 24 comes with npm > 11.5.1 which we need in order to publish with
OIDC auth.

This also reverts the change in commit e03a54e, which broke the
publishing step.
This should have been a part of commit 243d7fd
This should have been a part of commit 243d7fd
Add a new configuration option `keep_device_awake` to allow noVNC to
stop the local display from going to sleep. This is especially useful
with view-only sessions.

This new option has been added to the configuration UI, making it easier
for users to configure. When this option is changed at runtime, we will
request/release the wake lock.

We only hold the view lock while connected to a server. We will also
attempt to reacquire the wakelock if we lost it due to a visibility
change (the tab becoming inactive, or during the transition into/from
fullscreen).

All existing unittests have been run, and the change has been manually
tested in Firefox 145. Additional tests will be added later.
Add an error state to the WakeLockManager state machine. This adds a
transition that can be detected from tests (it otherwise serves no
purpose, and the system immediatly transitions back into the released
state).
Dispatch an event on each state transition inside the WakeLockManager.
This gives the unit tests something to synchronise on, allowing us to
write fast, flake-free tests.
Add tests to for both the `rfb` side (calling into the new wakelock
code), and the new wakelock class (which tracks the desired state and
how to get there).
I noticed a simple typo - "inoder rendering"
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.