@@ -78,6 +78,7 @@ function makeTestLayer(state: {
7878 remoteInvalidationCalls : number ;
7979 remoteStatusRefreshUpstreamValues ?: Array < boolean | undefined > ;
8080 backgroundWorkEnabled ?: boolean ;
81+ beforeRemoteStatus ?: Effect . Effect < void , GitManagerError > ;
8182} ) {
8283 return VcsStatusBroadcaster . layer . pipe (
8384 Layer . provideMerge ( NodeServices . layer ) ,
@@ -90,9 +91,10 @@ function makeTestLayer(state: {
9091 return state . currentLocalStatus ;
9192 } ) ,
9293 remoteStatus : ( _input , options ) =>
93- Effect . sync ( ( ) => {
94+ Effect . gen ( function * ( ) {
9495 state . remoteStatusCalls += 1 ;
9596 state . remoteStatusRefreshUpstreamValues ?. push ( options ?. refreshUpstream ) ;
97+ yield * state . beforeRemoteStatus ?? Effect . void ;
9698 return state . currentRemoteStatus ;
9799 } ) ,
98100 invalidateLocalStatus : ( ) =>
@@ -415,6 +417,134 @@ describe("VcsStatusBroadcaster", () => {
415417 } ) . pipe ( Effect . provide ( makeTestLayer ( state ) ) ) ;
416418 } ) ;
417419
420+ it . effect ( "publishes local changes while an older remote refresh holds the write lock" , ( ) => {
421+ const remoteStarted = Deferred . makeUnsafe < void > ( ) ;
422+ const releaseRemote = Deferred . makeUnsafe < void > ( ) ;
423+ const initialSnapshot = Deferred . makeUnsafe < void > ( ) ;
424+ const localUpdated = Deferred . makeUnsafe < VcsStatusLocalResult > ( ) ;
425+ const refreshedSnapshot = Deferred . makeUnsafe < VcsStatusStreamEvent > ( ) ;
426+ const state = {
427+ currentLocalStatus : baseLocalStatus ,
428+ currentRemoteStatus : baseRemoteStatus ,
429+ localStatusCalls : 0 ,
430+ remoteStatusCalls : 0 ,
431+ localInvalidationCalls : 0 ,
432+ remoteInvalidationCalls : 0 ,
433+ beforeRemoteStatus : Effect . void ,
434+ } ;
435+
436+ return Effect . gen ( function * ( ) {
437+ const broadcaster = yield * VcsStatusBroadcaster . VcsStatusBroadcaster ;
438+ yield * broadcaster . getStatus ( { cwd : "/repo" } ) ;
439+ yield * broadcaster
440+ . streamStatus (
441+ { cwd : "/repo" } ,
442+ { automaticRemoteRefreshInterval : Effect . succeed ( Duration . zero ) } ,
443+ )
444+ . pipe (
445+ Stream . runForEach ( ( event ) => {
446+ if ( event . _tag === "localUpdated" ) return Deferred . succeed ( localUpdated , event . local ) ;
447+ if ( event . _tag === "snapshot" && event . local . hasWorkingTreeChanges ) {
448+ return Deferred . succeed ( refreshedSnapshot , event ) ;
449+ }
450+ return Deferred . succeed ( initialSnapshot , undefined ) ;
451+ } ) ,
452+ Effect . forkScoped ,
453+ ) ;
454+ yield * Deferred . await ( initialSnapshot ) ;
455+ state . beforeRemoteStatus = Deferred . succeed ( remoteStarted , undefined ) . pipe (
456+ Effect . andThen ( Deferred . await ( releaseRemote ) ) ,
457+ ) ;
458+ const olderRefresh = yield * broadcaster . refreshStatus ( "/repo" ) . pipe ( Effect . forkScoped ) ;
459+ yield * Deferred . await ( remoteStarted ) ;
460+ state . currentLocalStatus = { ...baseLocalStatus , hasWorkingTreeChanges : true } ;
461+ state . currentRemoteStatus = remoteStatusWithPr ;
462+
463+ const immediate = yield * broadcaster . refreshStatus ( "/repo" , { waitForRemote : false } ) ;
464+ assert . isTrue ( immediate . hasWorkingTreeChanges ) ;
465+ assert . isNull ( immediate . pr ) ;
466+ assert . deepStrictEqual ( yield * Deferred . await ( localUpdated ) , state . currentLocalStatus ) ;
467+
468+ yield * Deferred . succeed ( releaseRemote , undefined ) ;
469+ yield * Fiber . join ( olderRefresh ) ;
470+ assert . deepStrictEqual ( yield * Deferred . await ( refreshedSnapshot ) , {
471+ _tag : "snapshot" ,
472+ local : state . currentLocalStatus ,
473+ remote : remoteStatusWithPr ,
474+ } ) ;
475+ } ) . pipe ( Effect . provide ( makeTestLayer ( state ) ) , Effect . scoped ) ;
476+ } ) ;
477+
478+ it . effect ( "coalesces remote work and cancels it when the broadcaster closes" , ( ) => {
479+ const remoteStarted = Deferred . makeUnsafe < void > ( ) ;
480+ const remoteInterrupted = Deferred . makeUnsafe < void > ( ) ;
481+ const state = {
482+ currentLocalStatus : baseLocalStatus ,
483+ currentRemoteStatus : baseRemoteStatus ,
484+ localStatusCalls : 0 ,
485+ remoteStatusCalls : 0 ,
486+ localInvalidationCalls : 0 ,
487+ remoteInvalidationCalls : 0 ,
488+ beforeRemoteStatus : Deferred . succeed ( remoteStarted , undefined ) . pipe (
489+ Effect . andThen ( Effect . never ) ,
490+ Effect . onInterrupt ( ( ) => Deferred . succeed ( remoteInterrupted , undefined ) ) ,
491+ ) ,
492+ } ;
493+
494+ return Effect . gen ( function * ( ) {
495+ yield * Effect . gen ( function * ( ) {
496+ const broadcaster = yield * VcsStatusBroadcaster . VcsStatusBroadcaster ;
497+ // No cached remote status: even the first request must return locally.
498+ const immediate = yield * broadcaster . refreshStatus ( "/repo" , { waitForRemote : false } ) ;
499+ assert . equal ( immediate . refName , baseLocalStatus . refName ) ;
500+ yield * Deferred . await ( remoteStarted ) ;
501+ yield * Effect . forEach (
502+ Array . from ( { length : 20 } ) ,
503+ ( ) => broadcaster . refreshStatus ( "/repo" , { waitForRemote : false } ) ,
504+ { concurrency : "unbounded" } ,
505+ ) ;
506+ assert . equal ( state . remoteStatusCalls , 1 ) ;
507+ } ) . pipe ( Effect . provide ( makeTestLayer ( state ) ) ) ;
508+ assert . isTrue ( Option . isSome ( yield * Deferred . poll ( remoteInterrupted ) ) ) ;
509+ } ) ;
510+ } ) ;
511+
512+ it . effect ( "clears failed remote work and does not return a previous branch's PR" , ( ) => {
513+ const state : Parameters < typeof makeTestLayer > [ 0 ] = {
514+ currentLocalStatus : baseLocalStatus ,
515+ currentRemoteStatus : remoteStatusWithPr ,
516+ localStatusCalls : 0 ,
517+ remoteStatusCalls : 0 ,
518+ localInvalidationCalls : 0 ,
519+ remoteInvalidationCalls : 0 ,
520+ beforeRemoteStatus : Effect . void ,
521+ } ;
522+
523+ return Effect . gen ( function * ( ) {
524+ const broadcaster = yield * VcsStatusBroadcaster . VcsStatusBroadcaster ;
525+ yield * broadcaster . getStatus ( { cwd : "/repo" } ) ;
526+ state . beforeRemoteStatus = Effect . fail (
527+ new GitManagerError ( {
528+ operation : "remoteStatus" ,
529+ cwd : "/repo" ,
530+ detail : "Network unavailable" ,
531+ } ) ,
532+ ) ;
533+ const cached = yield * broadcaster . refreshStatus ( "/repo" , { waitForRemote : false } ) ;
534+ assert . deepStrictEqual ( cached . pr , remoteStatusWithPr . pr ) ;
535+ yield * TestClock . adjust ( Duration . zero ) ;
536+
537+ state . currentLocalStatus = { ...baseLocalStatus , refName : "feature/next" } ;
538+ state . currentRemoteStatus = baseRemoteStatus ;
539+ state . beforeRemoteStatus = Effect . void ;
540+ const switched = yield * broadcaster . refreshStatus ( "/repo" , { waitForRemote : false } ) ;
541+ assert . isNull ( switched . pr ) ;
542+ yield * TestClock . adjust ( Duration . zero ) ;
543+ assert . equal ( state . remoteStatusCalls , 3 ) ;
544+ assert . isNull ( ( yield * broadcaster . getStatus ( { cwd : "/repo" } ) ) . pr ) ;
545+ } ) . pipe ( Effect . provide ( makeTestLayer ( state ) ) ) ;
546+ } ) ;
547+
418548 it . effect ( "keeps the cached snapshot unchanged when a refresh branch fails" , ( ) => {
419549 const state = {
420550 currentLocalStatus : baseLocalStatus ,
0 commit comments