Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

fix(core): TestBed should still use the microtask queue to schedule effects #53843

Closed
wants to merge 2 commits into from
Closed

fix(core): TestBed should still use the microtask queue to schedule effects #53843

wants to merge 2 commits into from

Conversation

atscott
Copy link
Contributor

@atscott atscott commented Jan 9, 2024

Prior to this commit, TestBed would require tests call flushEffects or fixture.detectChanges in order to execute effects. In general, we want to discourage authoring tests like this because it makes the timing of change detection and effects differ from what happens in the application. Instead, developers should perform actions and await (or flush/tick when using fakeAsync) some Promise so that Angular can react to the changes in the same way that it does in the application.

Note that this still allows developers to flush effects synchronously with flushEffects and detectChanges but also enables the , await pattern described above.

@atscott
fix(core): TestBed should still use the microtask queue to schedule e…
7a71f25 
…ffects

Prior to this commit, `TestBed` would require tests call `flushEffects`
or `fixture.detectChanges` in order to execute effects. In general, we
want to discourage authoring tests like this because it makes the timing
of change detection and effects differ from what happens in the
application. Instead, developers should perform actions and `await` (or
`flush`/`tick` when using `fakeAsync`) some `Promise` so that Angular
can react to the changes in the same way that it does in the
application.

Note that this still _allows_ developers to flush effects synchronously
with `flushEffects` and `detectChanges` but also enables the <action>,
`await` pattern described above.
@atscott atscott requested a review from alxhub January 9, 2024 00:23
@atscott atscott added target: patch This PR is targeted for the next patch release area: core Issues related to the framework runtime labels Jan 9, 2024
@ngbot ngbot bot added this to the Backlog milestone Jan 9, 2024
alxhub
alxhub approved these changes Jan 11, 2024
View reviewed changes
packages/core/src/render3/reactivity/effect.ts Outdated Show resolved Hide resolved
@atscott atscott added the action: merge The PR is ready for merge by the caretaker label Jan 11, 2024
@ngbot
Copy link

ngbot bot commented Jan 11, 2024

I see that you just added the action: merge label, but the following checks are still failing:
    failure status "google-internal-tests" is failing

If you want your PR to be merged, it has to pass all the CI checks.

If you can't get the PR to a green state due to flakes or broken main, please try rebasing to main and/or restarting the CI job. If that fails and you believe that the issue is not due to your change, please contact the caretaker and ask for help.

@atscott
Copy link
Contributor Author

atscott commented Jan 11, 2024

This PR was merged into the repository by commit 1f8c53c.

@atscott atscott closed this in 1f8c53c Jan 11, 2024
atscott added a commit that referenced this pull request Jan 11, 2024
@atscott
fix(core): TestBed should still use the microtask queue to schedule e…
198e64a 
…ffects (#53843)

Prior to this commit, `TestBed` would require tests call `flushEffects`
or `fixture.detectChanges` in order to execute effects. In general, we
want to discourage authoring tests like this because it makes the timing
of change detection and effects differ from what happens in the
application. Instead, developers should perform actions and `await` (or
`flush`/`tick` when using `fakeAsync`) some `Promise` so that Angular
can react to the changes in the same way that it does in the
application.

Note that this still _allows_ developers to flush effects synchronously
with `flushEffects` and `detectChanges` but also enables the <action>,
`await` pattern described above.

PR Close #53843
atscott added a commit that referenced this pull request Jan 11, 2024
@atscott
fix(core): TestBed should still use the microtask queue to schedule e…
0daca45 
…ffects (#53843)

Prior to this commit, `TestBed` would require tests call `flushEffects`
or `fixture.detectChanges` in order to execute effects. In general, we
want to discourage authoring tests like this because it makes the timing
of change detection and effects differ from what happens in the
application. Instead, developers should perform actions and `await` (or
`flush`/`tick` when using `fakeAsync`) some `Promise` so that Angular
can react to the changes in the same way that it does in the
application.

Note that this still _allows_ developers to flush effects synchronously
with `flushEffects` and `detectChanges` but also enables the <action>,
`await` pattern described above.

PR Close #53843
ChellappanRajan pushed a commit to ChellappanRajan/angular that referenced this pull request Jan 23, 2024
@atscott @ChellappanRajan
fix(core): TestBed should still use the microtask queue to schedule e…
c86e514 
…ffects (angular#53843)

Prior to this commit, `TestBed` would require tests call `flushEffects`
or `fixture.detectChanges` in order to execute effects. In general, we
want to discourage authoring tests like this because it makes the timing
of change detection and effects differ from what happens in the
application. Instead, developers should perform actions and `await` (or
`flush`/`tick` when using `fakeAsync`) some `Promise` so that Angular
can react to the changes in the same way that it does in the
application.

Note that this still _allows_ developers to flush effects synchronously
with `flushEffects` and `detectChanges` but also enables the <action>,
`await` pattern described above.

PR Close angular#53843
rlmestre pushed a commit to rlmestre/angular that referenced this pull request Jan 26, 2024
@atscott @rlmestre
fix(core): TestBed should still use the microtask queue to schedule e…
4b75547 
…ffects (angular#53843)

Prior to this commit, `TestBed` would require tests call `flushEffects`
or `fixture.detectChanges` in order to execute effects. In general, we
want to discourage authoring tests like this because it makes the timing
of change detection and effects differ from what happens in the
application. Instead, developers should perform actions and `await` (or
`flush`/`tick` when using `fakeAsync`) some `Promise` so that Angular
can react to the changes in the same way that it does in the
application.

Note that this still _allows_ developers to flush effects synchronously
with `flushEffects` and `detectChanges` but also enables the <action>,
`await` pattern described above.

PR Close angular#53843
danieljancar pushed a commit to danieljancar/angular that referenced this pull request Jan 26, 2024
@atscott @danieljancar
fix(core): TestBed should still use the microtask queue to schedule e…
5c1dbba 
…ffects (angular#53843)

Prior to this commit, `TestBed` would require tests call `flushEffects`
or `fixture.detectChanges` in order to execute effects. In general, we
want to discourage authoring tests like this because it makes the timing
of change detection and effects differ from what happens in the
application. Instead, developers should perform actions and `await` (or
`flush`/`tick` when using `fakeAsync`) some `Promise` so that Angular
can react to the changes in the same way that it does in the
application.

Note that this still _allows_ developers to flush effects synchronously
with `flushEffects` and `detectChanges` but also enables the <action>,
`await` pattern described above.

PR Close angular#53843
amilamen pushed a commit to amilamen/angular that referenced this pull request Jan 26, 2024
@atscott @amilamen
fix(core): TestBed should still use the microtask queue to schedule e…
e3e1c19 
…ffects (angular#53843)

Prior to this commit, `TestBed` would require tests call `flushEffects`
or `fixture.detectChanges` in order to execute effects. In general, we
want to discourage authoring tests like this because it makes the timing
of change detection and effects differ from what happens in the
application. Instead, developers should perform actions and `await` (or
`flush`/`tick` when using `fakeAsync`) some `Promise` so that Angular
can react to the changes in the same way that it does in the
application.

Note that this still _allows_ developers to flush effects synchronously
with `flushEffects` and `detectChanges` but also enables the <action>,
`await` pattern described above.

PR Close angular#53843
@angular-automatic-lock-bot
Copy link

This issue has been automatically locked due to inactivity.
Please file a new issue if you are encountering a similar or related problem.

Read more about our automatic conversation locking policy.

This action has been performed automatically by a bot.

@angular-automatic-lock-bot angular-automatic-lock-bot bot locked and limited conversation to collaborators Feb 11, 2024
Sign up for free to subscribe to this conversation on GitHub. Already have an account? Sign in.
Reviewers

@alxhub alxhub alxhub approved these changes

Assignees
No one assigned
Labels
action: merge The PR is ready for merge by the caretaker area: core Issues related to the framework runtime target: patch This PR is targeted for the next patch release
Projects
None yet
Milestone
Backlog
Development

Successfully merging this pull request may close these issues.

None yet
2 participants
@atscott @alxhub