Unverified Commit caa595eb authored by Tobias Koppers's avatar Tobias Koppers Committed by GitHub

Turbopack: handle removed routes (#77890)

### Why?

Before `get_endpoints` gives you a lot of `Vc<Endpoint>`, which we keep around and subscribe to. That is a problem as endpoint can also vanish at any time. e. g. when the folder is removed.
`Vc<Endpoint>` was not able to represent this state. The subscription throw an error as the Vc is no longer existant. So the error was technically correct here (not a bug in turbo-tasks).
But in practice we don't want to have this error. We want to have a clean end of the subscription without any error. That's why I change it to `Vc<Option<Endpoint>>`, which allows to represent the non-existance of an endpoint.
This can (resp. need to be) handled in subscriptions, which can report e. g. a `NotFound` result or a change event (for server_changed).

### What?

avoid having inactive Vcs when routes are removed.

instead use an `Option<Endpoint>` to allow respresenting removed endpoints and handle these in subscriptions correctly.
parent 87d7d8eb
...@@ -3,10 +3,11 @@ use std::{ops::Deref, sync::Arc}; ...@@ -3,10 +3,11 @@ use std::{ops::Deref, sync::Arc};
use anyhow::Result; use anyhow::Result;
use napi::{bindgen_prelude::External, JsFunction}; use napi::{bindgen_prelude::External, JsFunction};
use next_api::{ use next_api::{
operation::OptionEndpoint,
paths::ServerPath, paths::ServerPath,
route::{ route::{
endpoint_server_changed_operation, endpoint_write_to_disk_operation, Endpoint, endpoint_client_changed_operation, endpoint_server_changed_operation,
EndpointOutputPaths, endpoint_write_to_disk_operation, EndpointOutputPaths,
}, },
}; };
use tracing::Instrument; use tracing::Instrument;
...@@ -71,7 +72,7 @@ impl From<Option<EndpointOutputPaths>> for NapiWrittenEndpoint { ...@@ -71,7 +72,7 @@ impl From<Option<EndpointOutputPaths>> for NapiWrittenEndpoint {
server_paths: server_paths.into_iter().map(From::from).collect(), server_paths: server_paths.into_iter().map(From::from).collect(),
..Default::default() ..Default::default()
}, },
None => Self { Some(EndpointOutputPaths::NotFound) | None => Self {
r#type: "none".to_string(), r#type: "none".to_string(),
..Default::default() ..Default::default()
}, },
...@@ -85,10 +86,10 @@ impl From<Option<EndpointOutputPaths>> for NapiWrittenEndpoint { ...@@ -85,10 +86,10 @@ impl From<Option<EndpointOutputPaths>> for NapiWrittenEndpoint {
// some async functions (in this case `endpoint_write_to_disk`) can cause // some async functions (in this case `endpoint_write_to_disk`) can cause
// higher-ranked lifetime errors. See https://github.com/rust-lang/rust/issues/102211 // higher-ranked lifetime errors. See https://github.com/rust-lang/rust/issues/102211
// 2. the type_complexity clippy lint. // 2. the type_complexity clippy lint.
pub struct ExternalEndpoint(pub VcArc<Box<dyn Endpoint>>); pub struct ExternalEndpoint(pub VcArc<OptionEndpoint>);
impl Deref for ExternalEndpoint { impl Deref for ExternalEndpoint {
type Target = VcArc<Box<dyn Endpoint>>; type Target = VcArc<OptionEndpoint>;
fn deref(&self) -> &Self::Target { fn deref(&self) -> &Self::Target {
&self.0 &self.0
...@@ -105,7 +106,7 @@ struct WrittenEndpointWithIssues { ...@@ -105,7 +106,7 @@ struct WrittenEndpointWithIssues {
#[turbo_tasks::function(operation)] #[turbo_tasks::function(operation)]
async fn get_written_endpoint_with_issues_operation( async fn get_written_endpoint_with_issues_operation(
endpoint_op: OperationVc<Box<dyn Endpoint>>, endpoint_op: OperationVc<OptionEndpoint>,
) -> Result<Vc<WrittenEndpointWithIssues>> { ) -> Result<Vc<WrittenEndpointWithIssues>> {
let write_to_disk_op = endpoint_write_to_disk_operation(endpoint_op); let write_to_disk_op = endpoint_write_to_disk_operation(endpoint_op);
let (written, issues, diagnostics, effects) = let (written, issues, diagnostics, effects) =
...@@ -214,7 +215,7 @@ impl Eq for EndpointIssuesAndDiags {} ...@@ -214,7 +215,7 @@ impl Eq for EndpointIssuesAndDiags {}
#[turbo_tasks::function(operation)] #[turbo_tasks::function(operation)]
async fn subscribe_issues_and_diags_operation( async fn subscribe_issues_and_diags_operation(
endpoint_op: OperationVc<Box<dyn Endpoint>>, endpoint_op: OperationVc<OptionEndpoint>,
should_include_issues: bool, should_include_issues: bool,
) -> Result<Vc<EndpointIssuesAndDiags>> { ) -> Result<Vc<EndpointIssuesAndDiags>> {
let changed_op = endpoint_server_changed_operation(endpoint_op); let changed_op = endpoint_server_changed_operation(endpoint_op);
...@@ -241,13 +242,6 @@ async fn subscribe_issues_and_diags_operation( ...@@ -241,13 +242,6 @@ async fn subscribe_issues_and_diags_operation(
} }
} }
#[turbo_tasks::function(operation)]
fn endpoint_client_changed_operation(
endpoint_op: OperationVc<Box<dyn Endpoint>>,
) -> Vc<Completion> {
endpoint_op.connect().client_changed()
}
#[napi(ts_return_type = "{ __napiType: \"RootTask\" }")] #[napi(ts_return_type = "{ __napiType: \"RootTask\" }")]
pub fn endpoint_client_changed_subscribe( pub fn endpoint_client_changed_subscribe(
#[napi(ts_arg_type = "{ __napiType: \"Endpoint\" }")] endpoint: External<ExternalEndpoint>, #[napi(ts_arg_type = "{ __napiType: \"Endpoint\" }")] endpoint: External<ExternalEndpoint>,
......
...@@ -9,7 +9,8 @@ use napi::{ ...@@ -9,7 +9,8 @@ use napi::{
use next_api::{ use next_api::{
entrypoints::Entrypoints, entrypoints::Entrypoints,
operation::{ operation::{
EntrypointsOperation, InstrumentationOperation, MiddlewareOperation, RouteOperation, EntrypointsOperation, InstrumentationOperation, MiddlewareOperation, OptionEndpoint,
RouteOperation,
}, },
project::{ project::{
DefineEnv, DraftModeOptions, PartialProjectOptions, Project, ProjectContainer, DefineEnv, DraftModeOptions, PartialProjectOptions, Project, ProjectContainer,
...@@ -580,7 +581,7 @@ pub struct NapiRoute { ...@@ -580,7 +581,7 @@ pub struct NapiRoute {
impl NapiRoute { impl NapiRoute {
fn from_route(pathname: String, value: RouteOperation, turbo_tasks: &NextTurboTasks) -> Self { fn from_route(pathname: String, value: RouteOperation, turbo_tasks: &NextTurboTasks) -> Self {
let convert_endpoint = |endpoint: OperationVc<Box<dyn Endpoint>>| { let convert_endpoint = |endpoint: OperationVc<OptionEndpoint>| {
Some(External::new(ExternalEndpoint(VcArc::new( Some(External::new(ExternalEndpoint(VcArc::new(
turbo_tasks.clone(), turbo_tasks.clone(),
endpoint, endpoint,
......
...@@ -3,7 +3,7 @@ use serde::{Deserialize, Serialize}; ...@@ -3,7 +3,7 @@ use serde::{Deserialize, Serialize};
use turbo_rcstr::RcStr; use turbo_rcstr::RcStr;
use turbo_tasks::{ use turbo_tasks::{
debug::ValueDebugFormat, get_effects, trace::TraceRawVcs, CollectiblesSource, FxIndexMap, debug::ValueDebugFormat, get_effects, trace::TraceRawVcs, CollectiblesSource, FxIndexMap,
NonLocalValue, OperationVc, ResolvedVc, Vc, NonLocalValue, OperationValue, OperationVc, ResolvedVc, TaskInput, Vc,
}; };
use turbopack_core::{diagnostics::Diagnostic, issue::IssueDescriptionExt}; use turbopack_core::{diagnostics::Diagnostic, issue::IssueDescriptionExt};
...@@ -25,9 +25,9 @@ pub struct EntrypointsOperation { ...@@ -25,9 +25,9 @@ pub struct EntrypointsOperation {
pub routes: FxIndexMap<RcStr, RouteOperation>, pub routes: FxIndexMap<RcStr, RouteOperation>,
pub middleware: Option<MiddlewareOperation>, pub middleware: Option<MiddlewareOperation>,
pub instrumentation: Option<InstrumentationOperation>, pub instrumentation: Option<InstrumentationOperation>,
pub pages_document_endpoint: OperationVc<Box<dyn Endpoint>>, pub pages_document_endpoint: OperationVc<OptionEndpoint>,
pub pages_app_endpoint: OperationVc<Box<dyn Endpoint>>, pub pages_app_endpoint: OperationVc<OptionEndpoint>,
pub pages_error_endpoint: OperationVc<Box<dyn Endpoint>>, pub pages_error_endpoint: OperationVc<OptionEndpoint>,
} }
/// Removes diagnostics, issues, and effects from the top-level `entrypoints` operation so that /// Removes diagnostics, issues, and effects from the top-level `entrypoints` operation so that
...@@ -53,96 +53,181 @@ impl EntrypointsOperation { ...@@ -53,96 +53,181 @@ impl EntrypointsOperation {
routes: e routes: e
.routes .routes
.iter() .iter()
.map(|(k, v)| (k.clone(), wrap_route(v, entrypoints))) .map(|(k, v)| (k.clone(), pick_route(entrypoints, k.clone(), v)))
.collect(), .collect(),
middleware: e.middleware.as_ref().map(|m| MiddlewareOperation { middleware: e.middleware.as_ref().map(|_| MiddlewareOperation {
endpoint: wrap(m.endpoint, entrypoints), endpoint: pick_endpoint(entrypoints, EndpointSelector::Middleware),
}), }),
instrumentation: e instrumentation: e
.instrumentation .instrumentation
.as_ref() .as_ref()
.map(|i| InstrumentationOperation { .map(|_| InstrumentationOperation {
node_js: wrap(i.node_js, entrypoints), node_js: pick_endpoint(entrypoints, EndpointSelector::InstrumentationNodeJs),
edge: wrap(i.edge, entrypoints), edge: pick_endpoint(entrypoints, EndpointSelector::InstrumentationEdge),
}), }),
pages_document_endpoint: wrap(e.pages_document_endpoint, entrypoints), pages_document_endpoint: pick_endpoint(entrypoints, EndpointSelector::PagesDocument),
pages_app_endpoint: wrap(e.pages_app_endpoint, entrypoints), pages_app_endpoint: pick_endpoint(entrypoints, EndpointSelector::PagesApp),
pages_error_endpoint: wrap(e.pages_error_endpoint, entrypoints), pages_error_endpoint: pick_endpoint(entrypoints, EndpointSelector::PagesError),
} }
.cell()) .cell())
} }
} }
fn wrap_route(route: &Route, entrypoints: OperationVc<Entrypoints>) -> RouteOperation { fn pick_route(entrypoints: OperationVc<Entrypoints>, key: RcStr, route: &Route) -> RouteOperation {
match route { match route {
Route::Page { Route::Page { .. } => RouteOperation::Page {
html_endpoint, html_endpoint: pick_endpoint(entrypoints, EndpointSelector::RoutePageHtml(key.clone())),
data_endpoint, data_endpoint: pick_endpoint(entrypoints, EndpointSelector::RoutePageData(key)),
} => RouteOperation::Page {
html_endpoint: wrap(*html_endpoint, entrypoints),
data_endpoint: wrap(*data_endpoint, entrypoints),
}, },
Route::PageApi { endpoint } => RouteOperation::PageApi { Route::PageApi { .. } => RouteOperation::PageApi {
endpoint: wrap(*endpoint, entrypoints), endpoint: pick_endpoint(entrypoints, EndpointSelector::RoutePageApi(key)),
}, },
Route::AppPage(pages) => RouteOperation::AppPage( Route::AppPage(pages) => RouteOperation::AppPage(
pages pages
.iter() .iter()
.map(|p| AppPageRouteOperation { .enumerate()
.map(|(i, p)| AppPageRouteOperation {
original_name: p.original_name.clone(), original_name: p.original_name.clone(),
html_endpoint: wrap(p.html_endpoint, entrypoints), html_endpoint: pick_endpoint(
rsc_endpoint: wrap(p.rsc_endpoint, entrypoints), entrypoints,
EndpointSelector::RouteAppPageHtml(key.clone(), i),
),
rsc_endpoint: pick_endpoint(
entrypoints,
EndpointSelector::RouteAppPageRsc(key.clone(), i),
),
}) })
.collect(), .collect(),
), ),
Route::AppRoute { Route::AppRoute { original_name, .. } => RouteOperation::AppRoute {
original_name,
endpoint,
} => RouteOperation::AppRoute {
original_name: original_name.clone(), original_name: original_name.clone(),
endpoint: wrap(*endpoint, entrypoints), endpoint: pick_endpoint(entrypoints, EndpointSelector::RouteAppRoute(key)),
}, },
Route::Conflict => RouteOperation::Conflict, Route::Conflict => RouteOperation::Conflict,
} }
} }
/// Given a resolved `Endpoint` and the `Entrypoints` operation that it comes from, connect the #[derive(
/// operation and return a `OperationVc` of the `Entrypoint`. This `Endpoint` operation will keep Debug,
/// the entire `Entrypoints` operation alive. Clone,
TaskInput,
Serialize,
Deserialize,
TraceRawVcs,
PartialEq,
Eq,
Hash,
ValueDebugFormat,
NonLocalValue,
OperationValue,
)]
enum EndpointSelector {
RoutePageHtml(RcStr),
RoutePageData(RcStr),
RoutePageApi(RcStr),
RouteAppPageHtml(RcStr, usize),
RouteAppPageRsc(RcStr, usize),
RouteAppRoute(RcStr),
InstrumentationNodeJs,
InstrumentationEdge,
Middleware,
PagesDocument,
PagesApp,
PagesError,
}
#[turbo_tasks::value(transparent)]
pub struct OptionEndpoint(Option<ResolvedVc<Box<dyn Endpoint>>>);
/// Given a selector and the `Entrypoints` operation that it comes from, connect the operation and
/// return an `OperationVc` containing the selected value. The returned operation will keep the
/// entire `Entrypoints` operation alive.
#[turbo_tasks::function(operation)] #[turbo_tasks::function(operation)]
fn wrap( async fn pick_endpoint(
endpoint: ResolvedVc<Box<dyn Endpoint>>,
op: OperationVc<Entrypoints>, op: OperationVc<Entrypoints>,
) -> Vc<Box<dyn Endpoint>> { selector: EndpointSelector,
let _ = op.connect(); ) -> Result<Vc<OptionEndpoint>> {
*endpoint let endpoints = op.connect().strongly_consistent().await?;
let endpoint = match selector {
EndpointSelector::InstrumentationNodeJs => {
endpoints.instrumentation.as_ref().map(|i| i.node_js)
}
EndpointSelector::InstrumentationEdge => endpoints.instrumentation.as_ref().map(|i| i.edge),
EndpointSelector::Middleware => endpoints.middleware.as_ref().map(|m| m.endpoint),
EndpointSelector::PagesDocument => Some(endpoints.pages_document_endpoint),
EndpointSelector::PagesApp => Some(endpoints.pages_app_endpoint),
EndpointSelector::PagesError => Some(endpoints.pages_error_endpoint),
EndpointSelector::RoutePageHtml(name) => {
if let Some(Route::Page { html_endpoint, .. }) = endpoints.routes.get(&name) {
Some(*html_endpoint)
} else {
None
}
}
EndpointSelector::RoutePageData(name) => {
if let Some(Route::Page { data_endpoint, .. }) = endpoints.routes.get(&name) {
Some(*data_endpoint)
} else {
None
}
}
EndpointSelector::RoutePageApi(name) => {
if let Some(Route::PageApi { endpoint }) = endpoints.routes.get(&name) {
Some(*endpoint)
} else {
None
}
}
EndpointSelector::RouteAppPageHtml(name, i) => {
if let Some(Route::AppPage(pages)) = endpoints.routes.get(&name) {
pages.get(i).as_ref().map(|p| p.html_endpoint)
} else {
None
}
}
EndpointSelector::RouteAppPageRsc(name, i) => {
if let Some(Route::AppPage(pages)) = endpoints.routes.get(&name) {
pages.get(i).as_ref().map(|p| p.rsc_endpoint)
} else {
None
}
}
EndpointSelector::RouteAppRoute(name) => {
if let Some(Route::AppRoute { endpoint, .. }) = endpoints.routes.get(&name) {
Some(*endpoint)
} else {
None
}
}
};
Ok(Vc::cell(endpoint))
} }
#[derive(Serialize, Deserialize, TraceRawVcs, PartialEq, Eq, ValueDebugFormat, NonLocalValue)] #[derive(Serialize, Deserialize, TraceRawVcs, PartialEq, Eq, ValueDebugFormat, NonLocalValue)]
pub struct InstrumentationOperation { pub struct InstrumentationOperation {
pub node_js: OperationVc<Box<dyn Endpoint>>, pub node_js: OperationVc<OptionEndpoint>,
pub edge: OperationVc<Box<dyn Endpoint>>, pub edge: OperationVc<OptionEndpoint>,
} }
#[derive(Serialize, Deserialize, TraceRawVcs, PartialEq, Eq, ValueDebugFormat, NonLocalValue)] #[derive(Serialize, Deserialize, TraceRawVcs, PartialEq, Eq, ValueDebugFormat, NonLocalValue)]
pub struct MiddlewareOperation { pub struct MiddlewareOperation {
pub endpoint: OperationVc<Box<dyn Endpoint>>, pub endpoint: OperationVc<OptionEndpoint>,
} }
#[turbo_tasks::value(shared)] #[turbo_tasks::value(shared)]
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
pub enum RouteOperation { pub enum RouteOperation {
Page { Page {
html_endpoint: OperationVc<Box<dyn Endpoint>>, html_endpoint: OperationVc<OptionEndpoint>,
data_endpoint: OperationVc<Box<dyn Endpoint>>, data_endpoint: OperationVc<OptionEndpoint>,
}, },
PageApi { PageApi {
endpoint: OperationVc<Box<dyn Endpoint>>, endpoint: OperationVc<OptionEndpoint>,
}, },
AppPage(Vec<AppPageRouteOperation>), AppPage(Vec<AppPageRouteOperation>),
AppRoute { AppRoute {
original_name: RcStr, original_name: RcStr,
endpoint: OperationVc<Box<dyn Endpoint>>, endpoint: OperationVc<OptionEndpoint>,
}, },
Conflict, Conflict,
} }
...@@ -160,6 +245,6 @@ pub enum RouteOperation { ...@@ -160,6 +245,6 @@ pub enum RouteOperation {
)] )]
pub struct AppPageRouteOperation { pub struct AppPageRouteOperation {
pub original_name: RcStr, pub original_name: RcStr,
pub html_endpoint: OperationVc<Box<dyn Endpoint>>, pub html_endpoint: OperationVc<OptionEndpoint>,
pub rsc_endpoint: OperationVc<Box<dyn Endpoint>>, pub rsc_endpoint: OperationVc<OptionEndpoint>,
} }
...@@ -10,7 +10,7 @@ use turbopack_core::{ ...@@ -10,7 +10,7 @@ use turbopack_core::{
output::OutputAssets, output::OutputAssets,
}; };
use crate::{paths::ServerPath, project::Project}; use crate::{operation::OptionEndpoint, paths::ServerPath, project::Project};
#[derive( #[derive(
TraceRawVcs, TraceRawVcs,
...@@ -97,17 +97,36 @@ async fn endpoint_output_assets_operation( ...@@ -97,17 +97,36 @@ async fn endpoint_output_assets_operation(
} }
#[turbo_tasks::function(operation)] #[turbo_tasks::function(operation)]
pub fn endpoint_write_to_disk_operation( pub async fn endpoint_write_to_disk_operation(
endpoint: OperationVc<Box<dyn Endpoint>>, endpoint: OperationVc<OptionEndpoint>,
) -> Vc<EndpointOutputPaths> { ) -> Result<Vc<EndpointOutputPaths>> {
endpoint_write_to_disk(endpoint.connect()) Ok(if let Some(endpoint) = *endpoint.connect().await? {
endpoint_write_to_disk(*endpoint)
} else {
EndpointOutputPaths::NotFound.cell()
})
}
#[turbo_tasks::function(operation)]
pub async fn endpoint_server_changed_operation(
endpoint: OperationVc<OptionEndpoint>,
) -> Result<Vc<Completion>> {
Ok(if let Some(endpoint) = *endpoint.connect().await? {
endpoint.server_changed()
} else {
Completion::new()
})
} }
#[turbo_tasks::function(operation)] #[turbo_tasks::function(operation)]
pub fn endpoint_server_changed_operation( pub async fn endpoint_client_changed_operation(
endpoint: OperationVc<Box<dyn Endpoint>>, endpoint: OperationVc<OptionEndpoint>,
) -> Vc<Completion> { ) -> Result<Vc<Completion>> {
endpoint.connect().server_changed() Ok(if let Some(endpoint) = *endpoint.connect().await? {
endpoint.client_changed()
} else {
Completion::new()
})
} }
#[turbo_tasks::value(shared)] #[turbo_tasks::value(shared)]
...@@ -131,6 +150,7 @@ pub enum EndpointOutputPaths { ...@@ -131,6 +150,7 @@ pub enum EndpointOutputPaths {
server_paths: Vec<ServerPath>, server_paths: Vec<ServerPath>,
client_paths: Vec<RcStr>, client_paths: Vec<RcStr>,
}, },
NotFound,
} }
/// The routes as map from pathname to route. (pathname includes the leading /// The routes as map from pathname to route. (pathname includes the leading
......
...@@ -50,6 +50,8 @@ describe(`app-dir-hmr`, () => { ...@@ -50,6 +50,8 @@ describe(`app-dir-hmr`, () => {
// The new page should be rendered // The new page should be rendered
const newHTML = await next.render('/folder-renamed') const newHTML = await next.render('/folder-renamed')
expect(newHTML).toContain('Hello') expect(newHTML).toContain('Hello')
expect(next.cliOutput).not.toContain('FATAL')
} finally { } finally {
// Rename it back // Rename it back
await next.renameFolder('app/folder-renamed', 'app/folder') await next.renameFolder('app/folder-renamed', 'app/folder')
...@@ -89,7 +91,6 @@ describe(`app-dir-hmr`, () => { ...@@ -89,7 +91,6 @@ describe(`app-dir-hmr`, () => {
// details are unimportant. // details are unimportant.
expect(fastRefreshLogs).toEqual( expect(fastRefreshLogs).toEqual(
expect.arrayContaining([ expect.arrayContaining([
{ source: 'log', message: '[Fast Refresh] rebuilding' },
{ {
source: 'log', source: 'log',
message: expect.stringContaining('[Fast Refresh] done in '), message: expect.stringContaining('[Fast Refresh] done in '),
...@@ -102,6 +103,8 @@ describe(`app-dir-hmr`, () => { ...@@ -102,6 +103,8 @@ describe(`app-dir-hmr`, () => {
await retry(async () => { await retry(async () => {
expect(await browser.elementByCss('p').text()).toBe('mac') expect(await browser.elementByCss('p').text()).toBe('mac')
}) })
expect(next.cliOutput).not.toContain('FATAL')
}) })
it.each(['node', 'node-module-var', 'edge', 'edge-module-var'])( it.each(['node', 'node-module-var', 'edge', 'edge-module-var'])(
...@@ -118,7 +121,7 @@ describe(`app-dir-hmr`, () => { ...@@ -118,7 +121,7 @@ describe(`app-dir-hmr`, () => {
expect(logs).toEqual( expect(logs).toEqual(
expect.arrayContaining([ expect.arrayContaining([
expect.objectContaining({ expect.objectContaining({
message: '[Fast Refresh] rebuilding', message: expect.stringContaining('[Fast Refresh] done'),
source: 'log', source: 'log',
}), }),
]) ])
...@@ -143,6 +146,8 @@ describe(`app-dir-hmr`, () => { ...@@ -143,6 +146,8 @@ describe(`app-dir-hmr`, () => {
await retry(async () => { await retry(async () => {
expect(await browser.elementByCss('p').text()).toBe('mac') expect(await browser.elementByCss('p').text()).toBe('mac')
}) })
expect(next.cliOutput).not.toContain('FATAL')
} }
) )
...@@ -168,10 +173,6 @@ describe(`app-dir-hmr`, () => { ...@@ -168,10 +173,6 @@ describe(`app-dir-hmr`, () => {
// TODO: Should assert on all logs but these are cluttered with logs from our test utils (e.g. playwright tracing or webdriver) // TODO: Should assert on all logs but these are cluttered with logs from our test utils (e.g. playwright tracing or webdriver)
expect(logs).toEqual( expect(logs).toEqual(
expect.arrayContaining([ expect.arrayContaining([
{
message: '[Fast Refresh] rebuilding',
source: 'log',
},
{ {
message: expect.stringContaining('[Fast Refresh] done in'), message: expect.stringContaining('[Fast Refresh] done in'),
source: 'log', source: 'log',
...@@ -187,6 +188,8 @@ describe(`app-dir-hmr`, () => { ...@@ -187,6 +188,8 @@ describe(`app-dir-hmr`, () => {
) )
// No MPA navigation triggered // No MPA navigation triggered
expect(await browser.eval('window.__TEST_NO_RELOAD')).toEqual(true) expect(await browser.eval('window.__TEST_NO_RELOAD')).toEqual(true)
expect(next.cliOutput).not.toContain('FATAL')
}) })
}) })
}) })
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment