@jbrowse/plugin-linear-genome-view 4.2.1 → 5.0.0-beta.1

package/esm/displayKitTests/perRegionTestEnv.js

@@ -0,0 +1,141 @@
+import { ConfigurationReference, ConfigurationSchema, } from '@jbrowse/core/configuration';
+import { BaseDisplay } from '@jbrowse/core/pluggableElementTypes';
+import MultiRegionDisplayMixin from '@jbrowse/display-kit/MultiRegionDisplayMixin';
+import TrackHeightMixin from '@jbrowse/display-kit/TrackHeightMixin';
+import baseLinearDisplayConfigSchema from '@jbrowse/display-kit/configSchema';
+import { fetchEachRegion } from '@jbrowse/display-kit/fetchEachRegion';
+import { createDisplayTestEnvironment } from '@jbrowse/display-test-utils';
+import { types } from '@jbrowse/mobx-state-tree';
+import { stateModelFactory as linearGenomeViewStateModelFactory } from '../LinearGenomeView/index.js';
+const DISPLAY_NAME = 'PerRegionTestDisplay';
+// A fresh schema per environment, and the state model is handed the very
+// instance the harness registered — the pattern every other testEnv follows. A
+// module-level singleton shared across PluginManagers leaves the display's
+// `configuration` reference unresolvable, and the gate then reads every slot as
+// undefined rather than erroring.
+function makeConfigSchema() {
+    return ConfigurationSchema(DISPLAY_NAME, {}, { baseConfiguration: baseLinearDisplayConfigSchema, explicitlyTyped: true });
+}
+function makeStateModel(control, gate, configSchema) {
+    return types
+        .compose(DISPLAY_NAME, BaseDisplay, 
+    // every real per-region display composes this, and the hover-clear
+    // reaction the foundation installs reads its `scrollTop`
+    TrackHeightMixin(), MultiRegionDisplayMixin(), types.model({
+        type: types.literal(DISPLAY_NAME),
+        configuration: ConfigurationReference(configSchema),
+    }))
+        .volatile(() => ({
+        /** every `fetchNeeded` call, as the region list it was handed */
+        fetchLog: [],
+        loadedData: new Map(),
+        /**
+         * What `regionFetchKey` answers. A volatile, not a `control` knob, and
+         * that is the point: a real display's key reads view state, so the
+         * autorun re-runs when it moves. A plain closure value would be memoized
+         * by the computed and never invalidate.
+         */
+        fetchKey: '',
+    }))
+        .views(self => ({
+        get gateEnabled() {
+            return gate.gateEnabled ?? false;
+        },
+        get densityGateEnabled() {
+            return gate.densityGateEnabled ?? false;
+        },
+        get densityTooLarge() {
+            return control.densityTooLarge;
+        },
+        get regionFetchKey() {
+            return self.fetchKey;
+        },
+        regionHasData(_displayedRegionIndex) {
+            control.cacheValidCalls += 1;
+            if (control.staleAnswers > 0) {
+                control.staleAnswers -= 1;
+                return false;
+            }
+            return true;
+        },
+    }))
+        .actions(self => ({
+        setFetchKey(key) {
+            self.fetchKey = key;
+        },
+        setLoaded(displayedRegionIndex, value) {
+            self.loadedData.set(displayedRegionIndex, value);
+        },
+        clearDisplaySpecificData() {
+            self.loadedData.clear();
+        },
+    }))
+        .actions(self => ({
+        fetchNeeded(needed) {
+            self.fetchLog.push(needed);
+            // The budget is read here, at issue, exactly as a real display reads it
+            // to put in its RPC args.
+            const byteLimit = self.resolvedByteLimit();
+            return fetchEachRegion(self, needed, {
+                // Annotated for the reason a real display's RPC return type is
+                // declared: the refusal arm and the payload arm have to stay
+                // distinguishable, and inference merges two object literals into one
+                // widened shape.
+                call: async () => {
+                    if (control.fetchDelayMs > 0) {
+                        await new Promise(r => setTimeout(r, control.fetchDelayMs));
+                    }
+                    if (control.failNextFetch) {
+                        control.failNextFetch = false;
+                        throw new Error('rpc failed');
+                    }
+                    // What a gated worker does: measure, then refuse or fetch. No
+                    // budget means no measurement at all, which is why `estimateCalls`
+                    // stays at zero for an ungated display.
+                    if (byteLimit === undefined) {
+                        return { value: 'data' };
+                    }
+                    control.estimateCalls += 1;
+                    const bytes = control.estimateBytes;
+                    return bytes > byteLimit
+                        ? { regionTooLarge: true, bytes }
+                        : { value: 'data', bytes };
+                },
+                onResult: (idx, result) => {
+                    self.setLoaded(idx, result.value);
+                },
+            });
+        },
+    }));
+}
+/**
+ * A real `MultiRegionDisplayMixin` display inside a real `LinearGenomeView`, so
+ * `afterAttach` runs and `installPerRegionFetchAutoruns` installs for real.
+ */
+export function createPerRegionTestEnvironment({ measuresBytes = false, gate, estimateBytes = 100, ...opts } = {}) {
+    const control = {
+        cacheValidCalls: 0,
+        staleAnswers: 0,
+        failNextFetch: false,
+        fetchDelayMs: 0,
+        estimateBytes,
+        estimateCalls: 0,
+        densityTooLarge: false,
+    };
+    const optIns = gate ?? { gateEnabled: measuresBytes };
+    const env = createDisplayTestEnvironment({
+        trackType: 'FeatureTrack',
+        displayName: DISPLAY_NAME,
+        configSchema: makeConfigSchema,
+        stateModel: (_pm, schema) => makeStateModel(control, optIns, schema),
+        viewModel: linearGenomeViewStateModelFactory,
+        assemblyEnd: 100_000,
+        // an empty display-config entry is still an entry: without one the harness
+        // leaves the display's `configuration` reference unresolved, and every slot
+        // the gate reads — `fetchSizeLimit` above all — answers undefined
+        displayConfig: {},
+        rpcCall: () => [],
+        ...opts,
+    });
+    return { ...env, control };
+}