rfellows commented on code in PR #11138:
URL: https://github.com/apache/nifi/pull/11138#discussion_r3079950526
##########
nifi-frontend/src/main/frontend/apps/nifi/src/app/pages/connectors/ui/connector-canvas/connector-canvas.component.ts:
##########
@@ -33,6 +33,7 @@ import { Navigation } from
'../../../../ui/common/navigation/navigation.componen
import * as ConnectorCanvasActions from
'../../state/connector-canvas/connector-canvas.actions';
import * as ConnectorCanvasSelectors from
'../../state/connector-canvas/connector-canvas.selectors';
import * as ConnectorCanvasEntityActions from
'../../state/connector-canvas-entity/connector-canvas-entity.actions';
+import { selectRouteParams } from
'../../state/connector-canvas/connector-canvas.selectors';
Review Comment:
This is already imported and available through `ConnectorCanvasSelectors` on
line 34. However, looking at it a bit more closely... it looks like it can
probably be imported from `@nifi/shared`. The import and re-export in the
canvas selectors isn't needed.
##########
nifi-frontend/src/main/frontend/apps/nifi/src/app/pages/connectors/state/connector-canvas/connector-canvas.effects.spec.ts:
##########
@@ -111,264 +118,307 @@ describe('ConnectorCanvasEffects', () => {
});
describe('loadConnectorFlow$', () => {
- it('should call getConnectorFlow and dispatch
loadConnectorFlowSuccess', () =>
- new Promise<void>((resolve) => {
- setup().then(({ effects, actions$, mockConnectorService }) => {
- const flowResponse = {
- processGroupFlow: {
- id: 'pg-123',
- parentGroupId: 'parent-456',
- breadcrumb: null,
- flow: {
- labels: [{ id: 'l1' }],
- funnels: [],
- inputPorts: [],
- outputPorts: [],
- remoteProcessGroups: [],
- processGroups: [],
- processors: [],
- connections: []
- }
- }
- };
- (mockConnectorService.getConnectorFlow as
Mock).mockReturnValue(of(flowResponse));
- actions$(
- of(
- loadConnectorFlow({
- connectorId: 'conn-a',
- processGroupId: 'pg-in'
- })
- )
- );
-
- effects.loadConnectorFlow$.subscribe((action) => {
-
expect(mockConnectorService.getConnectorFlow).toHaveBeenCalledWith('conn-a',
'pg-in');
- expect(action).toEqual(
- loadConnectorFlowSuccess({
- connectorId: 'conn-a',
- processGroupId: 'pg-123',
- parentProcessGroupId: 'parent-456',
- breadcrumb: null,
- labels: [{ id: 'l1' }],
- funnels: [],
- inputPorts: [],
- outputPorts: [],
- remoteProcessGroups: [],
- processGroups: [],
- processors: [],
- connections: []
- })
- );
- resolve();
- });
- });
- }));
-
- it('should default flow collections when processGroupFlow.flow is
missing', () =>
- new Promise<void>((resolve) => {
- setup().then(({ effects, actions$, mockConnectorService }) => {
- const flowResponse = {
- processGroupFlow: {
- id: 'pg-123',
- parentGroupId: null,
- breadcrumb: null
- }
- };
- (mockConnectorService.getConnectorFlow as
Mock).mockReturnValue(of(flowResponse));
- actions$(
- of(
- loadConnectorFlow({
- connectorId: 'conn-a',
- processGroupId: 'pg-in'
- })
- )
- );
-
- effects.loadConnectorFlow$.subscribe((action) => {
- expect(action).toEqual(
- loadConnectorFlowSuccess({
- connectorId: 'conn-a',
- processGroupId: 'pg-123',
- parentProcessGroupId: null,
- breadcrumb: null,
- labels: [],
- funnels: [],
- inputPorts: [],
- outputPorts: [],
- remoteProcessGroups: [],
- processGroups: [],
- processors: [],
- connections: []
- })
- );
- resolve();
- });
- });
- }));
-
- it('should dispatch loadConnectorFlowFailure when getConnectorFlow
errors', () =>
- new Promise<void>((resolve) => {
- setup().then(({ effects, actions$, mockConnectorService,
mockErrorHelper }) => {
- const errorResponse = new HttpErrorResponse({ error:
'Failed', status: 500, statusText: 'ISE' });
- (mockConnectorService.getConnectorFlow as
Mock).mockReturnValue(throwError(() => errorResponse));
- actions$(
- of(
- loadConnectorFlow({
- connectorId: 'conn-a',
- processGroupId: 'pg-in'
- })
- )
- );
-
- effects.loadConnectorFlow$.subscribe((action) => {
-
expect(mockErrorHelper.getErrorString).toHaveBeenCalledWith(errorResponse);
- expect(action).toEqual(
- loadConnectorFlowFailure({
- errorContext: {
- errors: ['Error message'],
- context: ErrorContextKey.CONNECTORS
- }
- })
- );
- resolve();
- });
- });
- }));
+ it('should call getConnectorFlow and dispatch
loadConnectorFlowSuccess', async () => {
+ const { effects, actions$, mockConnectorService } = await setup();
+ const flowResponse = {
+ processGroupFlow: {
+ id: 'pg-123',
+ parentGroupId: 'parent-456',
+ breadcrumb: null,
+ flow: {
+ labels: [{ id: 'l1' }],
+ funnels: [],
+ inputPorts: [],
+ outputPorts: [],
+ remoteProcessGroups: [],
+ processGroups: [],
+ processors: [],
+ connections: []
+ }
+ }
+ };
+ (mockConnectorService.getConnectorFlow as
Mock).mockReturnValue(of(flowResponse));
+ actions$(
+ of(
+ loadConnectorFlow({
+ connectorId: 'conn-a',
+ processGroupId: 'pg-in'
+ })
+ )
+ );
+
+ const action = await firstValueFrom(effects.loadConnectorFlow$);
+
expect(mockConnectorService.getConnectorFlow).toHaveBeenCalledWith('conn-a',
'pg-in');
+ expect(action).toEqual(
+ loadConnectorFlowSuccess({
+ connectorId: 'conn-a',
+ processGroupId: 'pg-123',
+ parentProcessGroupId: 'parent-456',
+ breadcrumb: null,
+ labels: [{ id: 'l1' }],
+ funnels: [],
+ inputPorts: [],
+ outputPorts: [],
+ remoteProcessGroups: [],
+ processGroups: [],
+ processors: [],
+ connections: []
+ })
+ );
+ });
+
+ it('should default flow collections when processGroupFlow.flow is
missing', async () => {
+ const { effects, actions$, mockConnectorService } = await setup();
+ const flowResponse = {
+ processGroupFlow: {
+ id: 'pg-123',
+ parentGroupId: null,
+ breadcrumb: null
+ }
+ };
+ (mockConnectorService.getConnectorFlow as
Mock).mockReturnValue(of(flowResponse));
+ actions$(
+ of(
+ loadConnectorFlow({
+ connectorId: 'conn-a',
+ processGroupId: 'pg-in'
+ })
+ )
+ );
+
+ const action = await firstValueFrom(effects.loadConnectorFlow$);
+ expect(action).toEqual(
+ loadConnectorFlowSuccess({
+ connectorId: 'conn-a',
+ processGroupId: 'pg-123',
+ parentProcessGroupId: null,
+ breadcrumb: null,
+ labels: [],
+ funnels: [],
+ inputPorts: [],
+ outputPorts: [],
+ remoteProcessGroups: [],
+ processGroups: [],
+ processors: [],
+ connections: []
+ })
+ );
+ });
+
+ it('should dispatch loadConnectorFlowFailure when getConnectorFlow
errors', async () => {
+ const { effects, actions$, mockConnectorService, mockErrorHelper }
= await setup();
+ const errorResponse = new HttpErrorResponse({ error: 'Failed',
status: 500, statusText: 'ISE' });
+ (mockConnectorService.getConnectorFlow as
Mock).mockReturnValue(throwError(() => errorResponse));
+ actions$(
+ of(
+ loadConnectorFlow({
+ connectorId: 'conn-a',
+ processGroupId: 'pg-in'
+ })
+ )
+ );
+
+ const action = await firstValueFrom(effects.loadConnectorFlow$);
+
expect(mockErrorHelper.getErrorString).toHaveBeenCalledWith(errorResponse);
+ expect(action).toEqual(
+ loadConnectorFlowFailure({
+ errorContext: {
+ errors: ['Error message'],
+ context: ErrorContextKey.CONNECTORS
+ }
+ })
+ );
+ });
});
describe('loadConnectorFlowComplete$', () => {
- it('should dispatch loadConnectorFlowComplete on
loadConnectorFlowSuccess', () =>
- new Promise<void>((resolve) => {
- setup().then(({ effects, actions$ }) => {
- actions$(
- of(
- loadConnectorFlowSuccess({
- connectorId: 'c1',
- processGroupId: 'pg1',
- parentProcessGroupId: null,
- breadcrumb: null,
- labels: [],
- funnels: [],
- inputPorts: [],
- outputPorts: [],
- remoteProcessGroups: [],
- processGroups: [],
- processors: [],
- connections: []
- })
- )
- );
-
- effects.loadConnectorFlowComplete$.subscribe((action) => {
- expect(action).toEqual(loadConnectorFlowComplete());
- resolve();
- });
- });
- }));
+ it('should dispatch loadConnectorFlowComplete on
loadConnectorFlowSuccess', async () => {
+ const { effects, actions$ } = await setup();
+ actions$(
+ of(
+ loadConnectorFlowSuccess({
+ connectorId: 'c1',
+ processGroupId: 'pg1',
+ parentProcessGroupId: null,
+ breadcrumb: null,
+ labels: [],
+ funnels: [],
+ inputPorts: [],
+ outputPorts: [],
+ remoteProcessGroups: [],
+ processGroups: [],
+ processors: [],
+ connections: []
+ })
+ )
+ );
+
+ const action = await
firstValueFrom(effects.loadConnectorFlowComplete$);
+ expect(action).toEqual(loadConnectorFlowComplete());
+ });
});
describe('enterProcessGroup$', () => {
- it('should navigate to the child process group canvas URL', () =>
- new Promise<void>((resolve) => {
- setup({ connectorId: 'my-connector' }).then(({ effects,
actions$, mockRouter }) => {
- actions$(
- of(
- enterProcessGroup({
- request: { id: 'child-pg-99' }
- })
- )
- );
-
- effects.enterProcessGroup$.subscribe(() => {
- expect(mockRouter.navigate).toHaveBeenCalledWith([
- '/connectors',
- 'my-connector',
- 'canvas',
- 'child-pg-99'
- ]);
- resolve();
- });
- });
- }));
+ it('should navigate to the child process group canvas URL', async ()
=> {
+ const { effects, actions$, mockRouter } = await setup({
connectorId: 'my-connector' });
+ actions$(
+ of(
+ enterProcessGroup({
+ request: { id: 'child-pg-99' }
+ })
+ )
+ );
+
+ await firstValueFrom(effects.enterProcessGroup$);
+ expect(mockRouter.navigate).toHaveBeenCalledWith(['/connectors',
'my-connector', 'canvas', 'child-pg-99']);
+ });
});
describe('leaveProcessGroup$', () => {
- it('should navigate to parent, then after loadConnectorFlowComplete
dispatch setSkipTransform and replaceUrl navigate', () =>
- new Promise<void>((resolve) => {
- setup({
- connectorId: 'conn-x',
- parentProcessGroupId: 'parent-pg',
- processGroupId: 'child-pg'
- }).then(({ effects, actions$, mockRouter, store }) => {
- const dispatchSpy = vi.spyOn(store, 'dispatch');
- const actionSubject = new Subject<Action>();
- actions$(actionSubject.asObservable());
-
- effects.leaveProcessGroup$.subscribe({
- complete: () => {
-
expect(mockRouter.navigate).toHaveBeenNthCalledWith(1, [
- '/connectors',
- 'conn-x',
- 'canvas',
- 'parent-pg'
- ]);
-
expect(dispatchSpy).toHaveBeenCalledWith(setSkipTransform({ skipTransform: true
}));
-
expect(mockRouter.navigate).toHaveBeenNthCalledWith(
- 2,
- [
- '/connectors',
- 'conn-x',
- 'canvas',
- 'parent-pg',
- ComponentType.ProcessGroup,
- 'child-pg'
- ],
- { replaceUrl: true }
- );
- resolve();
+ it('should navigate to parent, then after loadConnectorFlowComplete
dispatch navigateWithoutTransform', async () => {
+ const { effects, actions$, mockRouter } = await setup({
+ connectorId: 'conn-x',
+ parentProcessGroupId: 'parent-pg',
+ processGroupId: 'child-pg'
+ });
+ const actionSubject = new Subject<Action>();
+ actions$(actionSubject.asObservable());
+
+ const resultPromise = firstValueFrom(effects.leaveProcessGroup$);
+
+ actionSubject.next(leaveProcessGroup());
+ actionSubject.next(loadConnectorFlowComplete());
+ actionSubject.complete();
+
+ const action = await resultPromise;
+ expect(mockRouter.navigate).toHaveBeenCalledWith(['/connectors',
'conn-x', 'canvas', 'parent-pg']);
+ expect(action).toEqual(
+ navigateWithoutTransform({
+ url: ['/connectors', 'conn-x', 'canvas', 'parent-pg',
ComponentType.ProcessGroup, 'child-pg']
+ })
+ );
+ });
+
+ it('should not navigate when parent process group id is null', async
() => {
+ const { effects, actions$, mockRouter } = await setup({
+ connectorId: 'conn-x',
+ parentProcessGroupId: null,
+ processGroupId: 'child-pg'
+ });
+ actions$(of(leaveProcessGroup()));
+
+ await firstValueFrom(effects.leaveProcessGroup$.pipe(() =>
of(undefined)));
+ expect(mockRouter.navigate).not.toHaveBeenCalled();
+ });
+
+ it('should not navigate when current process group id is null', async
() => {
+ const { effects, actions$, mockRouter } = await setup({
+ connectorId: 'conn-x',
+ parentProcessGroupId: 'parent-pg',
+ processGroupId: null
+ });
+ actions$(of(leaveProcessGroup()));
+
+ await firstValueFrom(effects.leaveProcessGroup$.pipe(() =>
of(undefined)));
+ expect(mockRouter.navigate).not.toHaveBeenCalled();
+ });
Review Comment:
In RxJS, `.pipe()` expects **operator functions** -- functions that take a
source observable and return a new observable using RxJS operators like `map`,
`filter`, `switchMap`, etc. But `() => of(undefined)` is a plain function that
**ignores its source argument entirely** and just returns `of(undefined)`.
So what actually happens:
1. `effects.leaveProcessGroup$` is created (the effect pipeline)
2. `.pipe(() => of(undefined))` wraps it, but the wrapper throws away the
source and returns `of(undefined)`
3. `firstValueFrom` subscribes and immediately gets `undefined` from
`of(undefined)`
4. The test then asserts `mockRouter.navigate` was not called -- which
passes, but only because the effect was never actually driven
The `filter` at line 202-204 of the effects file is the logic being "tested"
here:
```202:204:nifi-frontend/src/main/frontend/apps/nifi/src/app/pages/connectors/state/connector-canvas/connector-canvas.effects.ts
filter(
([, , parentProcessGroupId, currentProcessGroupId]) =>
parentProcessGroupId != null && currentProcessGroupId !=
null
),
```
These tests are supposed to prove that when `parentProcessGroupId` or
`processGroupId` is `null`, the filter blocks navigation. But the tests pass
regardless of whether that filter exists.
**Recommendation:**
The tricky part is that when the `filter` blocks, `leaveProcessGroup$`
simply never emits. Testing "nothing happened" is inherently awkward. Two
reasonable approaches:
**Option A** -- Subscribe, flush, then assert (simplest):
```typescript
it('should not navigate when parent process group id is null', async () => {
const { effects, actions$, mockRouter } = await setup({
connectorId: 'conn-x',
parentProcessGroupId: null,
processGroupId: 'child-pg'
});
actions$(of(leaveProcessGroup()));
// Subscribe to drive the pipeline, then check nothing happened
const results: any[] = [];
effects.leaveProcessGroup$.subscribe((action) => results.push(action));
expect(results).toEqual([]);
expect(mockRouter.navigate).not.toHaveBeenCalled();
});
```
**Option B** -- Use `firstValueFrom` with a timeout that rejects (more
explicit):
```typescript
it('should not navigate when parent process group id is null', async () => {
const { effects, actions$, mockRouter } = await setup({
connectorId: 'conn-x',
parentProcessGroupId: null,
processGroupId: 'child-pg'
});
actions$(of(leaveProcessGroup()));
await expect(
firstValueFrom(effects.leaveProcessGroup$.pipe(timeout(50)))
).rejects.toThrow();
expect(mockRouter.navigate).not.toHaveBeenCalled();
});
```
Option A is simpler because the source observable
(`of(leaveProcessGroup())`) is synchronous, so the effect pipeline runs
synchronously through the filter. By the time the next line executes, the
filter has already blocked (or not). No async timing issues.
##########
nifi-frontend/src/main/frontend/apps/nifi/src/app/pages/connectors/state/connector-canvas/connector-canvas.selectors.ts:
##########
@@ -19,7 +19,7 @@ import { createFeatureSelector, createSelector } from
'@ngrx/store';
import { getRouterSelectors } from '@ngrx/router-store';
import { ConnectorCanvasState, connectorCanvasFeatureKey } from './index';
-const { selectRouteParams } = getRouterSelectors();
+export const { selectRouteParams } = getRouterSelectors();
Review Comment:
I don't think we need export this here. In fact, it can be imported from
`@nifi/shared` and not needed from router-store.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]