Skip to content

Instantly share code, notes, and snippets.

Avatar
💭
Building cool things at @testimio

Benjamin Gruenbaum benjamingr

💭
Building cool things at @testimio
View GitHub Profile
View horrible-hack.js
'use strict';
require('v8').setFlagsFromString('--allow-natives-syntax');
// Extracted from v8/src/runtime/runtime.h
const methodNames = [
"Abort",
"AbortJS",
"AbortCSAAssert",
"ArraySpeciesProtector",
@benjamingr
benjamingr / gist:0237932cee84712951a2
Last active Oct 30, 2020
Promise unhandled rejection tracking global handler hook
View gist:0237932cee84712951a2

Possibly Unhandled Rejection NodeJS Promise Hook

###Unhandled Rejection Tracking

Several promise libraries such as bluebird and when as well as some native promise implementations offer potentially unhandled rejection tracking. This means that the following:

Promise.reject(new Error("err")); // never attach a `catch`
View intercept-network-requests.js
function interceptNetworkRequests(ee) {
const open = XMLHttpRequest.prototype.open;
const send = XMLHttpRequest.prototype.send;
const isRegularXHR = open.toString().indexOf('native code') !== -1;
// don't hijack if already hijacked - this will mess up with frameworks like Angular with zones
// we work if we load first there which we can.
if (isRegularXHR) {
View testimio.md

Testim.io

Who am I

Hi, I'm Benji, I'm a developer @ Testim.io for the last year and a half. I was asked to write a little about how we work here at Testim.io. Other than that this is me on GitHub and Stack Overflow.

Developer Point of View.

Testim is an E2E functional test recording and playback tool. We automate the hard parts of end to end testing which are stability and fast authoring. In addition we provide a lot of useful root-cause analysis information for your tests.

View really_bad_idea.ts
// a non recursively assimilating promise without error recovery
class NonAssimilatingPromise<T, E> {
public value?: T;
constructor(value?: T, public error?: E) {
if (value) {
this.value = value;
}
}
then<T2, E2>(fn: (value: T) => NonAssimilatingPromise<T2, E2>): NonAssimilatingPromise<T2, E | E2> {
if (this.error) {
View bad_idea.js
class Throws<T> {
constructor(public error?: T) {
}
then<S>(fn: () => Throws<S>): Throws<T | S> {
if (this.error) {
// already errored, don't attempt to run the next action
return this;
}
const result = fn();
View answer.md

A Promise handles a single event when an async operation completes or fails.

So, a promise doesn't handle anything - a promise is just a value over time. The charactaristics of promises are that:

  • Because a promise is just a value - promises are multicast which means multiple .thens are 'transparent'.
  • Native promises are what async functions return and what they await.
  • Promises have three states (fulfilled, pending and rejected) and transition between them just once.

Promises aren't really eager - but if you have a promise an operation has already started - so terms lik running promises don't make sense. They have a built in (stage 4 and part of JavaScript) multi-value counterpart (async iterators) which do multiple values and

@benjamingr
benjamingr / chrome_click.cc
Created Apr 16, 2019
What happens on a click
View chrome_click.cc
// actual differences (in chrome, IE, Firefox, Safari an Edge are all different) are:
// - behavior in disabled 'form' controls
// - phoning to home base (not here, it's defined elsewhere, can dig it up)
// - dealing with clicks dispatching clicks 'recursively'
// this is HTMLElement::click
void HTMLElement::click() {
DispatchSimulatedClick(nullptr, kSendNoEvents,
SimulatedClickCreationScope::kFromScript);
}
View xhr-in-fetch.js
class Dispatch extends EventTarget {
dispatch(eventName) {
const ev = new Event(eventName);
if (("on" + eventName) in this) {
this["on" + eventName](ev);
}
this.dispatchEvent(ev);
}
}
class XMLHttpRequest extends Dispatch {
View shadow-dom-utils.js
function querySelectorAllDeep(root, selector) {
const [start, ...rest] = Array.isArray(selector) ? selector : selector.split(" /deep/ ");
if (rest.length === 0) return [...root.querySelectorAll(start)];
return [...root.querySelectorAll(start + " *")].map(x => x.shadowRoot).filter(Boolean).map(x => querySelectorAllDeep(x, rest)).flat();
}
function unshadowDOM(dom, tagnNameOverride) {
const root = document.createElement(tagnNameOverride || dom.tagName || "fragment");
for(const {name, value} of (dom.attributes || [])) {
try {
You can’t perform that action at this time.