"
36 | ],
37 | "license": "MIT",
38 | "dependencies": {
39 | "@wojtekmaj/enzyme-adapter-utils": "^0.2.0",
40 | "enzyme-shallow-equal": "^1.0.0",
41 | "has": "^1.0.0",
42 | "prop-types": "^15.7.0",
43 | "react-is": "^17.0.0",
44 | "react-test-renderer": "^17.0.0"
45 | },
46 | "devDependencies": {
47 | "@babel/cli": "^7.15.0",
48 | "@babel/core": "^7.15.0",
49 | "@babel/preset-env": "^7.15.0",
50 | "@babel/preset-react": "^7.15.0",
51 | "enzyme": "^3.0.0",
52 | "eslint": "^8.26.0",
53 | "eslint-config-wojtekmaj": "^0.8.3",
54 | "husky": "^8.0.0",
55 | "prettier": "^2.7.0",
56 | "pretty-quick": "^3.1.0",
57 | "react": "^17.0.0",
58 | "react-dom": "^17.0.0",
59 | "rimraf": "^3.0.0"
60 | },
61 | "peerDependencies": {
62 | "enzyme": "^3.0.0",
63 | "react": "^17.0.0-0",
64 | "react-dom": "^17.0.0-0"
65 | },
66 | "publishConfig": {
67 | "access": "public"
68 | },
69 | "files": [
70 | "build",
71 | "src",
72 | "index.d.ts"
73 | ],
74 | "repository": {
75 | "type": "git",
76 | "url": "https://github.com/wojtekmaj/enzyme-adapter-react-17.git"
77 | },
78 | "funding": "https://github.com/wojtekmaj/enzyme-adapter-react-17?sponsor=1",
79 | "packageManager": "yarn@3.1.0"
80 | }
81 |
--------------------------------------------------------------------------------
/test/test/shared/lifecycles/getSnapshotBeforeUpdate.jsx:
--------------------------------------------------------------------------------
1 | import { describe, it } from 'vitest';
2 | import React from 'react';
3 |
4 | import { argSpy, expectArgs } from '../../_helpers';
5 |
6 | export default function describeGSBU({ Wrap }) {
7 | describe('getSnapshotBeforeUpdate()', () => {
8 | it('calls getSnapshotBeforeUpdate and pass snapshot to componentDidUpdate', () => {
9 | const spy = argSpy();
10 |
11 | class Foo extends React.Component {
12 | constructor(props) {
13 | super(props);
14 | this.state = {
15 | foo: 'bar',
16 | };
17 | }
18 |
19 | componentDidUpdate(prevProps, prevState, snapshot) {
20 | spy('componentDidUpdate', prevProps, this.props, prevState, this.state, snapshot);
21 | }
22 |
23 | getSnapshotBeforeUpdate(prevProps, prevState) {
24 | spy('getSnapshotBeforeUpdate', prevProps, this.props, prevState, this.state);
25 | return { snapshot: 'ok' };
26 | }
27 |
28 | render() {
29 | spy('render');
30 | return foo
;
31 | }
32 | }
33 | const wrapper = Wrap(
21 | Add
22 | {text}
23 |
24 | );
25 | }
26 |
27 | function reducer(state, action) {
28 | switch (action.type) {
29 | case 'ADD_TEXT':
30 | return [...state, action.payload];
31 | default:
32 | throw new Error();
33 | }
34 | }
35 |
36 | function FooBarTextList() {
37 | const [state, dispatch] = useReducer(reducer, initialState);
38 |
39 | return (
40 |
41 |
42 |
43 | {state.map((text) => (
44 |
{text}
45 | ))}
46 |
;
55 | const two =
;
56 | const three =
;
57 | const wrapper = Wrap(
58 |
59 | {one}
60 | {two}
61 | {three}
62 |
,
63 | );
64 | const counter =
;
55 | const two =
;
56 | const three =
;
57 | const wrapper = Wrap(
58 |
59 | {one}
60 | {two}
61 | {three}
62 |
,
63 | );
64 | const counter =
;
66 | },
67 | });
68 | const wrapper = Wrap(
;
78 | },
79 | });
80 | const wrapper = Wrap(
;
72 | }
73 | }
74 | const wrapper = Wrap(
;
87 | }
88 | }
89 | const wrapper = Wrap(
;
39 | }
40 | }
41 |
42 | itIf(isMount, 'called on root should return props of root node', () => {
43 | const wrapper = Wrap(
;
62 |
63 | itIf(isMount, 'called on root should return props of root node', () => {
64 | const wrapper = Wrap(
);
10 | expect(wrapper.is('.foo')).to.equal(true);
11 | });
12 |
13 | it('allows for compound selectors', () => {
14 | const wrapper = Wrap(
);
15 | expect(wrapper.is('.foo.bar')).to.equal(true);
16 | });
17 |
18 | it('ignores insignificant whitespace', () => {
19 | const className = `
20 | foo
21 | `;
22 | const wrapper = Wrap(
);
23 | expect(wrapper.is('.foo')).to.equal(true);
24 | });
25 |
26 | it('handles all significant whitespace', () => {
27 | const className = `foo
28 |
29 | bar
30 | baz`;
31 | const wrapper = Wrap(
);
32 | expect(wrapper.is('.foo.bar.baz')).to.equal(true);
33 | });
34 |
35 | it('returns false when selector does not match', () => {
36 | const wrapper = Wrap(
);
37 | expect(wrapper.is('.foo')).to.equal(false);
38 | });
39 |
40 | class RendersDiv extends React.Component {
41 | render() {
42 | return
;
43 | }
44 | }
45 | const Memoized = memo(RendersDiv);
46 | const ForwardRef = forwardRef(() =>
59 | ,
61 | );
62 | expect(wrapper.is(RendersDiv)).to.equal(true);
63 | });
64 |
65 | describe('forwardRef', () => {
66 | it('recognizes forwardRef', () => {
67 | const wrapper = WrapRendered(
68 |
69 | ,
71 | );
72 | expect(wrapper.is(ForwardRef)).to.equal(true);
73 | });
74 | });
75 |
76 | describe('React.memo', () => {
77 | it('recognizes memoized and inner', () => {
78 | const wrapper = WrapRendered(
79 |
80 | ,
82 | );
83 | expect(wrapper.is(Memoized)).to.equal(true);
84 | // expect(wrapper.is(RendersDiv)).to.equal(true);
85 | });
86 |
87 | it('recognizes memoized forwardRef and inner', () => {
88 | const wrapper = WrapRendered(
89 |
90 | ,
92 | );
93 | expect(wrapper.is(MemoForwardRef)).to.equal(true);
94 | });
95 | });
96 | });
97 | }
98 |
--------------------------------------------------------------------------------
/.github/workflows/ci.yml:
--------------------------------------------------------------------------------
1 | # This workflow will do a clean install of node dependencies and run tests
2 | # For more information see: https://help.github.com/actions/language-and-framework-guides/using-nodejs-with-github-actions
3 |
4 | name: CI
5 |
6 | on:
7 | push:
8 | branches: ['*']
9 | pull_request:
10 | branches: [main]
11 |
12 | jobs:
13 | lint:
14 | name: Static code analysis
15 | runs-on: ubuntu-latest
16 |
17 | steps:
18 | - name: Checkout
19 | uses: actions/checkout@v3
20 |
21 | - name: Cache .yarn/cache
22 | uses: actions/cache@v3
23 | env:
24 | cache-name: yarn-cache
25 | with:
26 | path: .yarn/cache
27 | key: ${{ runner.os }}-${{ env.cache-name }}-${{ hashFiles('**/yarn.lock') }}
28 | restore-keys: |
29 | ${{ runner.os }}-${{ env.cache-name }}
30 |
31 | - name: Use Node.js
32 | uses: actions/setup-node@v3
33 | with:
34 | node-version: '18'
35 |
36 | - name: Enable Corepack
37 | run: corepack enable
38 |
39 | - name: Install dependencies
40 | run: yarn --immutable
41 | env:
42 | HUSKY: 0
43 |
44 | - name: Run tests
45 | run: yarn lint
46 |
47 | prettier:
48 | name: Prettier
49 | runs-on: ubuntu-latest
50 |
51 | steps:
52 | - name: Checkout
53 | uses: actions/checkout@v3
54 |
55 | - name: Cache .yarn/cache
56 | uses: actions/cache@v3
57 | env:
58 | cache-name: yarn-cache
59 | with:
60 | path: .yarn/cache
61 | key: ${{ runner.os }}-${{ env.cache-name }}-${{ hashFiles('**/yarn.lock') }}
62 | restore-keys: |
63 | ${{ runner.os }}-${{ env.cache-name }}
64 |
65 | - name: Use Node.js
66 | uses: actions/setup-node@v3
67 | with:
68 | node-version: '18'
69 |
70 | - name: Enable Corepack
71 | run: corepack enable
72 |
73 | - name: Install dependencies
74 | run: yarn --immutable
75 | env:
76 | HUSKY: 0
77 |
78 | - name: Prettier
79 | run: yarn prettier
80 |
81 | test:
82 | name: Tests
83 | runs-on: ubuntu-latest
84 |
85 | steps:
86 | - name: Checkout
87 | uses: actions/checkout@v3
88 |
89 | - name: Cache .yarn/cache
90 | uses: actions/cache@v3
91 | env:
92 | cache-name: yarn-cache
93 | with:
94 | path: .yarn/cache
95 | key: ${{ runner.os }}-${{ env.cache-name }}-${{ hashFiles('**/yarn.lock') }}
96 | restore-keys: |
97 | ${{ runner.os }}-${{ env.cache-name }}
98 |
99 | - name: Use Node.js
100 | uses: actions/setup-node@v3
101 | with:
102 | node-version: '18'
103 |
104 | - name: Enable Corepack
105 | run: corepack enable
106 |
107 | - name: Install dependencies
108 | run: yarn --immutable
109 | env:
110 | HUSKY: 0
111 |
112 | - name: Build
113 | run: yarn build
114 |
115 | - name: Run tests
116 | run: yarn run
117 | working-directory: test
118 |
--------------------------------------------------------------------------------
/test/test/shared/methods/matchesElement.jsx:
--------------------------------------------------------------------------------
1 | import { describe, expect, it, vi } from 'vitest';
2 | import React from 'react';
3 |
4 | export default function describeMatchesElement({ Wrap, WrapRendered }) {
5 | describe('.matchesElement(node)', () => {
6 | it('matches on a root node that looks like the rendered one', () => {
7 | const spy = vi.fn();
8 | const wrapper = Wrap(
9 |
10 |
11 | Hello World
12 |
13 |
25 |
26 | Hello World
27 |
28 |
53 |
54 | Hello World
55 |
56 |
61 |
Bonjour le monde
62 |
68 |
69 | Hello World
70 |
71 |
test ;
96 | }
97 | }
98 | const wrapper = WrapRendered(test )).to.equal(true);
100 | });
101 | });
102 | }
103 |
--------------------------------------------------------------------------------
/test/test/shared/methods/equals.jsx:
--------------------------------------------------------------------------------
1 | import { describe, expect, it } from 'vitest';
2 | import React from 'react';
3 |
4 | export default function describeEquals({ Wrap, WrapRendered }) {
5 | describe('.equals(node)', () => {
6 | it('allows matches on the root node', () => {
7 | const a =
;
8 | const b =
;
9 | const c =
;
10 |
11 | expect(Wrap(a).equals(b)).to.equal(true);
12 | expect(Wrap(a).equals(c)).to.equal(false);
13 | });
14 |
15 | it('does NOT allow matches on a nested node', () => {
16 | const wrapper = Wrap(
17 | ,
20 | );
21 | const b =
;
22 | expect(wrapper.equals(b)).to.equal(false);
23 | });
24 |
25 | it('matches composite components', () => {
26 | class Foo extends React.Component {
27 | render() {
28 | return
;
29 | }
30 | }
31 | const wrapper = Wrap(
32 |
33 |
,
35 | );
36 | const b = (
37 |
38 |
40 | );
41 | expect(wrapper.equals(b)).to.equal(true);
42 | });
43 |
44 | it('does not expand `node` content', () => {
45 | class Bar extends React.Component {
46 | render() {
47 | return
;
48 | }
49 | }
50 |
51 | class Foo extends React.Component {
52 | render() {
53 | return
;
65 |
66 | const wrapper = Wrap(
67 |
68 |
,
70 | );
71 | const b = (
72 |
73 |
75 | );
76 | expect(wrapper.equals(b)).to.equal(true);
77 | });
78 |
79 | it('does not expand `node` content', () => {
80 | const Bar = () =>
;
81 |
82 | const Foo = () => {title}
;
17 | }
18 |
19 | const customTitle = 'CustomTitle';
20 |
21 | function App() {
22 | return (
23 |
24 |
26 | );
27 | }
28 |
29 | it('render ui component with initial context value', () => {
30 | const wrapper = Wrap(
56 |
57 | increment
58 |
59 | {myContextVal.state}
60 |
61 | );
62 | }
63 |
64 | function MyChild() {
65 | return (
66 |
67 |
69 | );
70 | }
71 |
72 | function App() {
73 | const [state, setState] = useState(initialState);
74 |
75 | return (
76 |
77 |
78 |
80 |
81 | );
82 | }
83 |
84 | it('test render, get and set context value ', () => {
85 | const wrapper = Wrap(
97 | ${String(initialState)}
98 | `);
99 |
100 | getGrandChild().find('button').props().onClick();
101 | wrapper.update();
102 | expect(getGrandChild().find('.grandChildState').debug()).to
103 | .equal(`
104 | ${String(initialState + 1)}
105 | `);
106 | });
107 | });
108 | });
109 | }
110 |
--------------------------------------------------------------------------------
/test/test/shared/hooks/useState.jsx:
--------------------------------------------------------------------------------
1 | import { describe, expect, it } from 'vitest';
2 | import React from 'react';
3 |
4 | import { itIf } from '../../_helpers';
5 |
6 | import { useState, useEffect, Fragment } from '../../_helpers/react-compat';
7 |
8 | export default function describeUseState({ Wrap, isShallow }) {
9 | describe('hooks: useState', () => {
10 | function FooCounter({ initialCount: initial = 0 }) {
11 | const [count, setCount] = useState(+initial);
12 |
13 | return (
14 |
15 | setCount(count + 1)}>
16 | -
17 |
18 | {count}
19 | setCount(count - 1)}>
20 | +
21 |
22 |
23 | );
24 | }
25 |
26 | const initialCount = 5;
27 |
28 | it('initial render', () => {
29 | const wrapper = Wrap({count}
;
53 | }
54 |
55 | const wrapper = Wrap( setCount(count + 1)}>{count}
;
65 | }
66 |
67 | const wrapper = Wrap(
88 | {count}
89 |
90 | );
91 | }
92 |
93 | // TODO: fixme when useEffect works in the shallow renderer, see https://github.com/facebook/react/issues/15275
94 | itIf(!isShallow, 'initial render & new Props', () => {
95 | const wrapper = Wrap(
20 | this.setState(({ count: oldCount }) => ({ count: oldCount + 1 }))}
23 | >
24 | {count}
25 |
26 |
27 | );
28 | }
29 | }
30 |
31 | class ClickableLink extends React.Component {
32 | render() {
33 | const { onClick } = this.props;
34 | return (
35 |
38 | );
39 | }
40 | }
41 |
42 | it('throws when pointing to a non-function prop', () => {
43 | const wrapper = Wrap(
);
44 |
45 | expect(() => wrapper.invoke('data-a')).to.throw(
46 | TypeError,
47 | `${WrapperName}::invoke() requires the name of a prop whose value is a function`,
48 | );
49 |
50 | expect(() => wrapper.invoke('does not exist')).to.throw(
51 | TypeError,
52 | `${WrapperName}::invoke() requires the name of a prop whose value is a function`,
53 | );
54 | });
55 |
56 | it('can update the state value', () => {
57 | const wrapper = Wrap( setCounter((input) => input + 1)}>
96 | {result}
97 |
98 | );
99 | }
100 | const wrapper = Wrap(
11 | Hello World!
12 |
,
13 | );
14 | expect(wrapper.html()).to.equal('Hello World!
');
15 | });
16 |
17 | it('renders out nested composite components', () => {
18 | class Foo extends React.Component {
19 | render() {
20 | return
;
21 | }
22 | }
23 | class Bar extends React.Component {
24 | render() {
25 | return (
26 |
27 |
29 | );
30 | }
31 | }
32 | const wrapper = Wrap(
');
35 | });
36 |
37 | describe('stateless function components (SFCs)', () => {
38 | it('renders out nested composite components', () => {
39 | const Foo = () =>
;
40 | const Bar = () => (
41 |
42 |
44 | );
45 |
46 | const wrapper = Wrap(
');
49 | });
50 | });
51 |
52 | describe('Fragments', () => {
53 | class FragmentClassExample extends React.Component {
54 | render() {
55 | return (
56 |
57 |
58 | Foo
59 |
60 |
61 | Bar
62 |
63 |
64 | );
65 | }
66 | }
67 |
68 | const FragmentConstExample = () => (
69 |
70 |
71 | Foo
72 |
73 |
74 | Bar
75 |
76 |
77 | );
78 |
79 | class ClassChild extends React.Component {
80 | render() {
81 | return Class child
;
82 | }
83 | }
84 |
85 | function SFCChild() {
86 | return SFC child
;
87 | }
88 |
89 | class FragmentWithCustomChildClass extends React.Component {
90 | render() {
91 | return (
92 |
93 |
96 | );
97 | }
98 | }
99 |
100 | it('correctly renders html for both children for class', () => {
101 | const classWrapper = Wrap(Foo
Bar
',
104 | );
105 | });
106 |
107 | it('correctly renders html for both children for const', () => {
108 | const constWrapper = Wrap(Foo
Bar
',
111 | );
112 | });
113 |
114 | it('correctly renders html for custom component children', () => {
115 | const withChildrenWrapper = Wrap(Class child
SFC child
');
117 | });
118 | });
119 | });
120 | }
121 |
--------------------------------------------------------------------------------
/test/test/shared/methods/hostNodes.jsx:
--------------------------------------------------------------------------------
1 | import { describe, expect, it } from 'vitest';
2 | import React from 'react';
3 |
4 | export default function describeHostNodes({ Wrap, WrapRendered }) {
5 | describe('.hostNodes()', () => {
6 | it('strips out any non-hostNode', () => {
7 | class Foo extends React.Component {
8 | render() {
9 | return
;
10 | }
11 | }
12 | const wrapper = Wrap(
13 |
14 |
16 | ,
17 | );
18 |
19 | const foos = wrapper.find('main > .foo');
20 | expect(foos).to.have.lengthOf(2);
21 |
22 | const hostNodes = foos.hostNodes();
23 | expect(hostNodes).to.have.lengthOf(1);
24 |
25 | expect(hostNodes.is('div')).to.equal(true);
26 | expect(hostNodes.hasClass('foo')).to.equal(true);
27 | });
28 |
29 | it('does NOT allow matches on a nested node', () => {
30 | const wrapper = Wrap(
31 | ,
34 | );
35 | const b =
;
36 | expect(wrapper.equals(b)).to.equal(false);
37 | });
38 |
39 | it('matches composite components', () => {
40 | class Foo extends React.Component {
41 | render() {
42 | return
;
43 | }
44 | }
45 |
46 | const wrapper = Wrap(
47 |
48 |
,
50 | );
51 | const b = (
52 |
53 |
55 | );
56 | expect(wrapper.equals(b)).to.equal(true);
57 | });
58 |
59 | it('does not expand `node` content', () => {
60 | class Bar extends React.Component {
61 | render() {
62 | return
;
63 | }
64 | }
65 |
66 | class Foo extends React.Component {
67 | render() {
68 | return
;
79 |
80 | const wrapper = Wrap(
81 |
82 |
,
84 | );
85 | const b = (
86 |
87 |
89 | );
90 | expect(wrapper.equals(b)).to.equal(true);
91 | });
92 |
93 | it('does not expand `node` content', () => {
94 | const Bar = () =>
;
95 |
96 | const Foo = () =>
;
100 | }
101 | }
102 |
103 | /**
104 | * Possible values for React render() checks.
105 | */
106 | export function generateEmptyRenderData() {
107 | return [
108 | // Returns true for empty
109 | { message: 'false', value: false, expectResponse: true },
110 | { message: 'null', value: null, expectResponse: true },
111 |
112 | // Returns false for empty, valid returns
113 | { message: 'React component', value: {name}
;
19 | },
20 | });
21 |
22 | function SimpleComponentSFC(props, { name }) {
23 | return {name}
;
24 | }
25 | SimpleComponentSFC.contextTypes = contextTypes;
26 |
27 | it('throws when not called on the root', () => {
28 | const context = { name:
73 | hi
74 |
75 | );
76 | }
77 | }
78 |
79 | it('throws on non-instance', () => {
80 | const wrapper = Wrap({children}
;
90 | }
91 | }
92 |
93 | it('throws on non-root', () => {
94 | const wrapper = Wrap(
95 |
96 | ,
98 | );
99 | const child = wrapper.find(RendersHTML);
100 | expect(child).to.have.lengthOf(1);
101 | expect(() => child.context()).to.throw(Error);
102 | });
103 |
104 | it('throws on an SFC without an instance', () => {
105 | function Bar() {
106 | return
111 | ,
113 | );
114 | const child = wrapper.find(Bar);
115 | expect(child).to.have.lengthOf(1);
116 | expect(() => child.context()).to.throw(Error);
117 | });
118 | });
119 | }
120 |
--------------------------------------------------------------------------------
/test/test/shared/methods/containsAnyMatchingElements.jsx:
--------------------------------------------------------------------------------
1 | import { describe, expect, it, vi } from 'vitest';
2 | import React from 'react';
3 |
4 | export default function describeContainsAnyMatchingElements({ Wrap }) {
5 | describe('.containsAnyMatchingElements(nodes)', () => {
6 | it('matches on an array with at least one node that looks like a rendered node', () => {
7 | const spy1 = vi.fn();
8 | const spy2 = vi.fn();
9 | const wrapper = Wrap(
10 |
11 |
12 | Hello World
13 |
14 |
15 | Goodbye World
16 |
17 |
Bonjour le monde
,
22 | Goodbye World
,
23 | ]),
24 | ).to.equal(true);
25 | expect(
26 | wrapper.containsAnyMatchingElements([
27 |
28 | Bonjour le monde
29 |
,
30 | Goodbye World
,
31 | ]),
32 | ).to.equal(true);
33 | expect(
34 | wrapper.containsAnyMatchingElements([
35 | Bonjour le monde
,
36 |
37 | Goodbye World
38 |
,
39 | ]),
40 | ).to.equal(true);
41 | expect(
42 | wrapper.containsAnyMatchingElements([
43 |
44 | Bonjour le monde
45 |
,
46 |
47 | Goodbye World
48 |
,
49 | ]),
50 | ).to.equal(true);
51 | expect(
52 | wrapper.containsAnyMatchingElements([
53 | Bonjour le monde
,
54 |
55 | Goodbye World
56 |
,
57 | ]),
58 | ).to.equal(true);
59 | expect(
60 | wrapper.containsAnyMatchingElements([
61 | Bonjour le monde
,
62 |
63 | Goodbye World
64 |
,
65 | ]),
66 | ).to.equal(true);
67 | expect(
68 | wrapper.containsAnyMatchingElements([
69 |
70 | Bonjour le monde
71 |
,
72 | Goodbye World
,
73 | ]),
74 | ).to.equal(true);
75 | expect(
76 | wrapper.containsAnyMatchingElements([
77 |
78 | Bonjour le monde
79 |
,
80 | Goodbye World
,
81 | ]),
82 | ).to.equal(true);
83 | expect(spy1).to.have.property('callCount', 0);
84 | expect(spy2).to.have.property('callCount', 0);
85 | });
86 |
87 | it('does not match on an array with no nodes that look like a rendered node', () => {
88 | const spy1 = vi.fn();
89 | const spy2 = vi.fn();
90 | const wrapper = Wrap(
91 |
92 |
93 | Hello World
94 |
95 |
96 | Goodbye World
97 |
98 |
103 | Bonjour le monde
104 |
,
105 | Au revoir le monde
,
106 | ]),
107 | ).to.equal(false);
108 | expect(spy1).to.have.property('callCount', 0);
109 | expect(spy2).to.have.property('callCount', 0);
110 | });
111 | });
112 | }
113 |
--------------------------------------------------------------------------------
/test/test/shared/methods/contains.jsx:
--------------------------------------------------------------------------------
1 | import { describe, expect, it } from 'vitest';
2 | import React from 'react';
3 |
4 | import { itIf } from '../../_helpers';
5 |
6 | export default function describeContains({ Wrap, WrapperName, isMount }) {
7 | describe('.contains(node)', () => {
8 | it('allows matches on the root node', () => {
9 | const a =
;
10 | const b =
;
11 | const c =
;
12 | const wrapper = Wrap(a);
13 | expect(wrapper.contains(b)).to.equal(true);
14 | expect(wrapper.contains(c)).to.equal(false);
15 | });
16 |
17 | it('allows matches on a nested node', () => {
18 | const wrapper = Wrap(
19 | ,
22 | );
23 | const b =
;
24 | expect(wrapper.contains(b)).to.equal(true);
25 | });
26 |
27 | it('matches composite components', () => {
28 | class Foo extends React.Component {
29 | render() {
30 | return
;
31 | }
32 | }
33 | const wrapper = Wrap(
34 |
35 |
,
37 | );
38 | const b = foo
);
44 |
45 | expect(wrapper.contains('foo')).to.equal(true);
46 | expect(wrapper.contains('bar')).to.equal(false);
47 | });
48 |
49 | it('works with numbers', () => {
50 | const wrapper = Wrap({1}
);
51 |
52 | expect(wrapper.contains(1)).to.equal(true);
53 | expect(wrapper.contains(2)).to.equal(false);
54 | expect(wrapper.contains('1')).to.equal(false);
55 | });
56 |
57 | it('works with nested strings & numbers', () => {
58 | const wrapper = Wrap(
59 | ,
65 | );
66 |
67 | expect(wrapper.contains('foo')).to.equal(true);
68 | expect(wrapper.contains(foo
)).to.equal(true);
69 |
70 | expect(wrapper.contains(5)).to.equal(true);
71 | expect(wrapper.contains({5}
)).to.equal(true);
72 | });
73 |
74 | it('does something with arrays of nodes', () => {
75 | const wrapper = Wrap(
76 |
77 |
Hello
78 |
Goodbye
79 |
More
80 |
wrong , Goodbye
];
83 |
84 | const passes1 = [Hello , Goodbye
];
85 | const passes2 = [Goodbye
, More ];
86 |
87 | expect(wrapper.contains(fails)).to.equal(false);
88 | expect(wrapper.contains(passes1)).to.equal(true);
89 | expect(wrapper.contains(passes2)).to.equal(true);
90 | });
91 |
92 | // FIXME: fix on mount
93 | itIf(!isMount, 'throws on invalid argument', () => {
94 | const wrapper = Wrap(
);
95 |
96 | expect(() => wrapper.contains({})).to.throw(
97 | Error,
98 | `${WrapperName}::contains() can only be called with a ReactElement (or an array of them), a string, or a number as an argument.`,
99 | );
100 | expect(() => wrapper.contains(() => ({}))).to.throw(
101 | Error,
102 | `${WrapperName}::contains() can only be called with a ReactElement (or an array of them), a string, or a number as an argument.`,
103 | );
104 | });
105 |
106 | describe('stateless function components (SFCs)', () => {
107 | it('matches composite components', () => {
108 | function Foo() {
109 | return
;
110 | }
111 |
112 | const wrapper = Wrap(
113 |
114 |
,
116 | );
117 | const b =
;
124 | }
125 | const renderStatelessComponent = () => {renderStatelessComponent()}
);
127 | const b =
;
22 | }
23 | }
24 |
25 | class FooWrapper extends React.Component {
26 | render() {
27 | return
;
41 | }
42 | const SFCWrapper = () =>
;
57 | },
58 | });
59 | const FooWrapper = createClass({
60 | render() {
61 | return
;
81 | }
82 | }
83 | const stub = getAdapter().displayNameOfNode;
84 | const sentinel = {};
85 | stub.mockReturnValue(sentinel);
86 |
87 | const wrapper = Wrap(
;
103 | }
104 | }
105 |
106 | class FooWrapper extends React.Component {
107 | render() {
108 | return
;
120 | }
121 | const SFCWrapper = () =>
);
132 | expect(wrapper.name()).to.equal('div');
133 | });
134 | });
135 | });
136 | }
137 |
--------------------------------------------------------------------------------
/test/test/staticRender.spec.jsx:
--------------------------------------------------------------------------------
1 | import { describe, expect, it } from 'vitest';
2 | import React from 'react';
3 | import PropTypes from 'prop-types';
4 | import { render } from 'enzyme';
5 | import renderEntry from 'enzyme/render';
6 | import { fakeDynamicImport } from '@wojtekmaj/enzyme-adapter-utils';
7 |
8 | import './_helpers/setupAdapters';
9 | import { createClass, lazy } from './_helpers/react-compat';
10 |
11 | describe('render', () => {
12 | describe('top level entry points', () => {
13 | it('exports the same renderEntry and render', () => {
14 | expect(renderEntry).to.equal(render);
15 | });
16 | });
17 |
18 | describe('context', () => {
19 | it('can pass in context', () => {
20 | const SimpleComponent = createClass({
21 | contextTypes: {
22 | name: PropTypes.string,
23 | },
24 | render() {
25 | const { name } = this.context;
26 | return {name}
;
27 | },
28 | });
29 |
30 | const context = { name: 'foo' };
31 | const wrapper = render(foo
');
38 | });
39 |
40 | it('can pass context to the child of mounted component', () => {
41 | const SimpleComponent = createClass({
42 | contextTypes: {
43 | name: PropTypes.string,
44 | },
45 | render() {
46 | const { name } = this.context;
47 | return {name} ;
48 | },
49 | });
50 | const ComplexComponent = createClass({
51 | render() {
52 | return (
53 |
54 |
56 | );
57 | },
58 | });
59 |
60 | const childContextTypes = {
61 | name: PropTypes.string.isRequired,
62 | };
63 | const context = { name: 'foo' };
64 | const wrapper = render(foo
');
76 | expect(String(children)).to.equal('foo ');
77 | });
78 |
79 | it('does not throw if context is passed in but contextTypes is missing', () => {
80 | const SimpleComponent = createClass({
81 | render() {
82 | const { name } = this.context;
83 | return {name}
;
84 | },
85 | });
86 |
87 | const context = { name: 'foo' };
88 | expect(() => render(Dynamic Component
;
133 | }
134 | }
135 | const LazyComponent = lazy(fakeDynamicImport(DynamicComponent));
136 | expect(() => render({children}
;
17 | }
18 | }
19 |
20 | class Spans extends React.Component {
21 | render() {
22 | return (
23 |
24 |
27 | );
28 | }
29 | }
30 |
31 | class Nested extends React.Component {
32 | render() {
33 | return (
34 |
35 |
37 | );
38 | }
39 | }
40 |
41 | it('throws on host elements', () => {
42 | const wrapper = WrapRendered(
);
43 | expect(wrapper.is('div')).to.equal(true);
44 | expect(() => wrapper.simulateError()).to.throw();
45 | });
46 |
47 | it('throws on "not one" node', () => {
48 | const wrapper = Wrap(Hello
);
8 |
9 | expect(() => wrapper.containsAllMatchingElements(Hello
)).to.throw(
10 | TypeError,
11 | 'nodes should be an Array',
12 | );
13 | });
14 |
15 | it('matches on array of nodes that each look like rendered nodes, with nested elements', () => {
16 | const wrapper = Wrap(
17 | ,
25 | );
26 |
27 | expect(wrapper.containsAllMatchingElements([Hello
, Goodbye
])).to.equal(true);
28 | });
29 |
30 | it('matches on an array of nodes that all look like one of the rendered nodes', () => {
31 | const spy1 = vi.fn();
32 | const spy2 = vi.fn();
33 | const wrapper = Wrap(
34 |
35 |
36 | Hello World
37 |
38 |
39 | Goodbye World
40 |
41 |
Hello World
, Goodbye World
]),
45 | ).to.equal(true);
46 | expect(
47 | wrapper.containsAllMatchingElements([
48 |
49 | Hello World
50 |
,
51 | Goodbye World
,
52 | ]),
53 | ).to.equal(true);
54 | expect(
55 | wrapper.containsAllMatchingElements([
56 | Hello World
,
57 |
58 | Goodbye World
59 |
,
60 | ]),
61 | ).to.equal(true);
62 | expect(
63 | wrapper.containsAllMatchingElements([
64 |
65 | Hello World
66 |
,
67 |
68 | Goodbye World
69 |
,
70 | ]),
71 | ).to.equal(true);
72 | expect(
73 | wrapper.containsAllMatchingElements([
74 | Hello World
,
75 |
76 | Goodbye World
77 |
,
78 | ]),
79 | ).to.equal(true);
80 | expect(
81 | wrapper.containsAllMatchingElements([
82 | Hello World
,
83 |
84 | Goodbye World
85 |
,
86 | ]),
87 | ).to.equal(true);
88 | expect(
89 | wrapper.containsAllMatchingElements([
90 |
91 | Hello World
92 |
,
93 | Goodbye World
,
94 | ]),
95 | ).to.equal(true);
96 | expect(
97 | wrapper.containsAllMatchingElements([
98 |
99 | Hello World
100 |
,
101 | Goodbye World
,
102 | ]),
103 | ).to.equal(true);
104 | expect(spy1).to.have.property('callCount', 0);
105 | expect(spy2).to.have.property('callCount', 0);
106 | });
107 |
108 | it('does not match on nodes that do not all look like one of the rendered nodes', () => {
109 | const spy1 = vi.fn();
110 | const spy2 = vi.fn();
111 | const wrapper = Wrap(
112 |
113 |
114 | Hello World
115 |
116 |
117 | Goodbye World
118 |
119 |
124 | Hello World
125 |
,
126 |
127 | Bonjour le monde
128 |
,
129 | Goodbye World
,
130 | ]),
131 | ).to.equal(false);
132 | expect(spy1).to.have.property('callCount', 0);
133 | expect(spy2).to.have.property('callCount', 0);
134 | });
135 | });
136 | }
137 |
--------------------------------------------------------------------------------
/test/test/shared/methods/parents.jsx:
--------------------------------------------------------------------------------
1 | import { describe, expect, it } from 'vitest';
2 | import React from 'react';
3 |
4 | import { itIf } from '../../_helpers';
5 |
6 | import { createClass } from '../../_helpers/react-compat';
7 |
8 | export default function describeParents({ Wrap, isShallow }) {
9 | describe('.parents([selector])', () => {
10 | it('returns an array of current node’s ancestors', () => {
11 | const wrapper = Wrap(
12 | ,
22 | );
23 |
24 | const parents = wrapper.find('.baz').parents();
25 |
26 | expect(parents).to.have.lengthOf(3);
27 | expect(parents.at(0).hasClass('bar')).to.equal(true);
28 | expect(parents.at(1).hasClass('foo')).to.equal(true);
29 | expect(parents.at(2).hasClass('bax')).to.equal(true);
30 | });
31 |
32 | it('works for non-leaf nodes as well', () => {
33 | const wrapper = Wrap(
34 | ,
41 | );
42 |
43 | const parents = wrapper.find('.bar').parents();
44 |
45 | expect(parents).to.have.lengthOf(2);
46 | expect(parents.at(0).hasClass('foo')).to.equal(true);
47 | expect(parents.at(1).hasClass('bax')).to.equal(true);
48 | });
49 |
50 | it('optionally allows a selector', () => {
51 | const wrapper = Wrap(
52 | ,
59 | );
60 |
61 | const parents = wrapper.find('.baz').parents('.foo');
62 |
63 | expect(parents).to.have.lengthOf(2);
64 | expect(parents.at(0).hasClass('foo')).to.equal(true);
65 | expect(parents.at(1).hasClass('bax')).to.equal(true);
66 | });
67 |
68 | it('works when called sequentially on two sibling nodes', () => {
69 | class Test extends React.Component {
70 | render() {
71 | return (
72 |
80 | );
81 | }
82 | }
83 |
84 | const wrapper = Wrap(
88 | A child
89 |
`);
90 | expect(aChild).to.have.lengthOf(1);
91 |
92 | const bChild = wrapper.find({ children: 'B child' });
93 | expect(bChild.debug()).to.equal(`
94 | B child
95 |
`);
96 | expect(bChild).to.have.lengthOf(1);
97 |
98 | const bChildParents = bChild.parents('.b');
99 | expect(bChildParents.debug()).to.equal(`
100 |
101 | B child
102 |
103 |
108 |
109 | A child
110 |
111 |
;
119 | },
120 | });
121 | const wrapper = Wrap(
122 |
123 |
,
125 | );
126 | const rootDiv = wrapper.find('.root');
127 | expect(rootDiv).to.have.lengthOf(1);
128 | expect(rootDiv.hasClass('root')).to.equal(true);
129 | expect(rootDiv.hasClass('bar')).to.equal(false);
130 |
131 | const bar = rootDiv.find('.bar');
132 | expect(bar).to.have.lengthOf(1);
133 | expect(bar.parents('.root')).to.have.lengthOf(1);
134 | });
135 |
136 | itIf(!isShallow, 'finds parents up a tree through a custom component boundary', () => {
137 | class CustomForm extends React.Component {
138 | render() {
139 | const { children } = this.props;
140 | return ;
141 | }
142 | }
143 |
144 | const wrapper = Wrap(
145 |
146 |
147 |
149 |
,
150 | );
151 |
152 | const formDown = wrapper.find('form');
153 | expect(formDown).to.have.lengthOf(1);
154 |
155 | const input = wrapper.find('input');
156 | expect(input).to.have.lengthOf(1);
157 | const formUp = input.parents('form');
158 | expect(formUp).to.have.lengthOf(1);
159 | });
160 | });
161 | }
162 |
--------------------------------------------------------------------------------
/test/test/shared/hooks/custom.jsx:
--------------------------------------------------------------------------------
1 | import { describe, expect, it, vi } from 'vitest';
2 | import React from 'react';
3 |
4 | import { describeIf } from '../../_helpers';
5 |
6 | import { useEffect, useState } from '../../_helpers/react-compat';
7 |
8 | export default function describeCustomHooks({ Wrap, isShallow }) {
9 | describe('hooks: custom', () => {
10 | describe('custom hook: useCounter', () => {
11 | function useCounter({ initialCount = 0, step = 1 } = {}) {
12 | const [count, setCount] = useState(initialCount);
13 | const increment = () => setCount((c) => c + step);
14 | const decrement = () => setCount((c) => c - step);
15 | return { count, increment, decrement };
16 | }
17 | // testing custom hooks with renderProps
18 | // may be we can think of adding in utils
19 | // will be repeated
20 | const Counter = ({ children, ...rest }) => children(useCounter(rest));
21 |
22 | function setupTest(props) {
23 | const returnVal = {};
24 | Wrap(
25 |
26 | {(val) => {
27 | Object.assign(returnVal, val);
28 | return null;
29 | }}
30 | ,
31 | );
32 | return returnVal;
33 | }
34 |
35 | it('useCounter', () => {
36 | const counterData = setupTest();
37 | counterData.increment();
38 | expect(counterData).to.have.property('count', 1);
39 | counterData.decrement();
40 | expect(counterData).to.have.property('count', 0);
41 | });
42 |
43 | it('useCounter with initialCount', () => {
44 | const counterData = setupTest({ initialCount: 2 });
45 | counterData.increment();
46 | expect(counterData).to.have.property('count', 3);
47 | counterData.decrement();
48 | expect(counterData).to.have.property('count', 2);
49 | });
50 |
51 | it('useCounter with step', () => {
52 | const counterData = setupTest({ step: 2 });
53 | counterData.increment();
54 | expect(counterData).to.have.property('count', 2);
55 | counterData.decrement();
56 | expect(counterData).to.have.property('count', 0);
57 | });
58 |
59 | it('useCounter with step and initialCount', () => {
60 | const counterData = setupTest({ step: 2, initialCount: 5 });
61 | counterData.increment();
62 | expect(counterData).to.have.property('count', 7);
63 | counterData.decrement();
64 | expect(counterData).to.have.property('count', 5);
65 | });
66 | });
67 |
68 | // todo: enable shallow when useEffect works in the shallow renderer. see https://github.com/facebook/react/issues/15275
69 | describeIf(!isShallow, 'custom hook: formInput invoke props', () => {
70 | function useFormInput(initialValue = '') {
71 | const [value, setValue] = useState(initialValue);
72 |
73 | return {
74 | value,
75 | onChange(e) {
76 | setValue(e.target.value);
77 | },
78 | };
79 | }
80 |
81 | function Input(props) {
82 | return (
83 |
84 |
86 | );
87 | }
88 |
89 | function ControlledInputWithEnhancedInput({ searchSomething }) {
90 | const search = useFormInput();
91 |
92 | useEffect(() => {
93 | searchSomething(search.value);
94 | }, [search.value]);
95 |
96 | return {name}
;
16 | },
17 | });
18 |
19 | it('sets context for a component multiple times', () => {
20 | const context = { name: 'foo' };
21 | const wrapper = Wrap({name}
;
50 | SFC.contextTypes = { name: PropTypes.string };
51 |
52 | it('sets context for a component multiple times', () => {
53 | const context = { name: 'foo' };
54 | const wrapper = Wrap({foo}
;
83 | }
84 | }
85 | Foo.contextTypes = {
86 | foo: PropTypes.string,
87 | };
88 |
89 | const wrapper = Wrap(
101 | baz
102 |
`
103 | : `
104 |
105 | baz
106 |
107 | `,
108 | );
109 | });
110 |
111 | it('calls componentWillReceiveProps and UNSAFE_componentWillReceiveProps when context is updated', () => {
112 | const spy = vi.fn();
113 | const updatedProps = { foo: 'baz' };
114 | class Foo extends React.Component {
115 | componentWillReceiveProps() {
116 | spy('componentWillReceiveProps');
117 | }
118 |
119 | UNSAFE_componentWillReceiveProps() {
120 | spy('UNSAFE_componentWillReceiveProps');
121 | }
122 |
123 | render() {
124 | spy('render');
125 | const { foo } = this.context;
126 | return {foo}
;
127 | }
128 | }
129 | Foo.contextTypes = {
130 | foo: PropTypes.string,
131 | };
132 |
133 | const wrapper = Wrap(
150 | baz
151 |
`
152 | : `
153 |
154 | baz
155 |
156 | `,
157 | );
158 | });
159 | });
160 | }
161 |
--------------------------------------------------------------------------------
/test/test/shared/methods/state.jsx:
--------------------------------------------------------------------------------
1 | import { describe, expect, it } from 'vitest';
2 | import React from 'react';
3 |
4 | import { itIf } from '../../_helpers';
5 |
6 | import { createPortal } from '../../_helpers/react-compat';
7 |
8 | export default function describeState({ Wrap, WrapperName, isShallow, makeDOMElement }) {
9 | describe('.state([name])', () => {
10 | class HasFooState extends React.Component {
11 | constructor(props) {
12 | super(props);
13 | this.state = { foo: 'foo' };
14 | }
15 |
16 | render() {
17 | const { foo } = this.state;
18 | return {foo}
;
19 | }
20 | }
21 |
22 | it('returns the state object', () => {
23 | const wrapper = Wrap(
41 |
,
43 | );
44 |
45 | expect(() => wrapper.state()).to.throw(
46 | Error,
47 | `${WrapperName}::state() can only be called on class components`,
48 | );
49 | });
50 |
51 | it('throws on Portals', () => {
52 | const containerDiv = makeDOMElement();
53 | const portal = createPortal(
, containerDiv);
54 |
55 | const wrapper = Wrap({portal}
);
56 | expect(() => wrapper.state()).to.throw(
57 | Error,
58 | `${WrapperName}::state() can only be called on class components`,
59 | );
60 | });
61 |
62 | describe('stateless function components (SFCs)', () => {
63 | it('throws on SFCs', () => {
64 | function FooSFC() {
65 | return
;
66 | }
67 |
68 | const wrapper = Wrap(
88 | {prop}
89 | {' - '}
90 | {state}
91 |
92 | );
93 | }
94 | }
95 |
96 | class Parent extends React.Component {
97 | constructor(...args) {
98 | super(...args);
99 | this.state = { childProp: 1 };
100 | }
101 |
102 | render() {
103 | const { childProp } = this.state;
104 | return
158 |
,
162 | );
163 | const spans = wrapper.find('span');
164 | expect(spans).to.have.lengthOf(3);
165 | expect(() => spans.state()).to.throw(
166 | Error,
167 | isShallow
168 | ? 'ShallowWrapper::state() can only be called on the root'
169 | : `${WrapperName}::getNode() can only be called when wrapping one node`,
170 | );
171 | });
172 | });
173 | }
174 |
--------------------------------------------------------------------------------
/test/test/shared/methods/props.jsx:
--------------------------------------------------------------------------------
1 | import { describe, expect, it } from 'vitest';
2 | import React from 'react';
3 |
4 | import { delay, itIf } from '../../_helpers';
5 |
6 | import sloppyReturnThis from '../../_helpers/untranspiledSloppyReturnThis';
7 |
8 | export default function describeProps({ Wrap, WrapRendered, isMount }) {
9 | describe('.props()', () => {
10 | it('returns the props object', () => {
11 | const fn = () => ({});
12 | const wrapper = Wrap(
13 | ,
17 | );
18 |
19 | expect(wrapper.props().className).to.equal('bax');
20 | expect(wrapper.props().onClick).to.equal(fn);
21 | expect(wrapper.props().id).to.equal('fooId');
22 | });
23 |
24 | it('is allowed to be used on an inner node', () => {
25 | const fn = () => ({});
26 | const wrapper = Wrap(
27 | ,
31 | );
32 |
33 | expect(wrapper.find('.baz').props().onClick).to.equal(fn);
34 | expect(wrapper.find('.foo').props().id).to.equal('fooId');
35 | });
36 |
37 | class Foo extends React.Component {
38 | render() {
39 | const { bar, foo } = this.props;
40 | return
;
41 | }
42 | }
43 |
44 | itIf(isMount, 'called on root should return props of root node', () => {
45 | const wrapper = Wrap(
;
58 |
59 | itIf(isMount, 'called on root should return props of root node', () => {
60 | const wrapper = Wrap(
78 | ));
79 |
80 | const StrictReceiver = function SFC(props = { NO_PROPS: true }, context) {
81 | return (
82 |
88 | );
89 | };
90 |
91 | it('does not provide a `this` to a sloppy-mode SFC', () => {
92 | const wrapper = WrapRendered(
131 |
133 | );
134 | }
135 | }
136 |
137 | class TestSubComponent extends React.Component {
138 | render() {
139 | const { counter } = this.props;
140 | return {counter}
;
141 | }
142 | }
143 |
144 | it('child component props should update after call to setState in async handler', () => {
145 | const wrapper = Wrap(
49 | ,
51 | );
52 |
53 | expect(wrapper.isEmptyRender()).to.equal(!isShallow);
54 | });
55 |
56 | it('returns false for multiple nested elements that all return null', () => {
57 | const wrapper = Wrap(
58 |
59 |
60 | ,
61 | );
62 |
63 | expect(wrapper.isEmptyRender()).to.equal(false);
64 | });
65 |
66 | it('returns false for multiple nested elements where one fringe returns a non null value', () => {
67 | const wrapper = Wrap(
68 |
69 | Hello
70 | ,
71 | );
72 |
73 | expect(wrapper.isEmptyRender()).to.equal(false);
74 | });
75 |
76 | it('returns false for multiple nested elements that all return null', () => {
77 | const wrapper = Wrap(
78 |
79 |
81 |
83 |
84 | ,
85 | );
86 |
87 | expect(wrapper.isEmptyRender()).to.equal(false);
88 | });
89 |
90 | it('returns false for multiple nested elements where one fringe returns a non null value', () => {
91 | const wrapper = Wrap(
92 |
93 |
95 |
98 |
99 |
101 | Hello
105 |
106 |
107 | ,
108 | );
109 |
110 | expect(wrapper.isEmptyRender()).to.equal(false);
111 | });
112 |
113 | it(`returns ${!isShallow} for multiple nested elements where all values are null`, () => {
114 | const wrapper = Wrap(
115 |
116 |
118 |
121 |
122 |
124 |
128 |
129 | ,
130 | );
131 |
132 | expect(wrapper.isEmptyRender()).to.equal(!isShallow);
133 | });
134 | });
135 |
136 | it('does not return true for HTML elements', () => {
137 | const wrapper = Wrap(
);
138 | expect(wrapper.isEmptyRender()).to.equal(false);
139 | });
140 |
141 | describe('stateless function components (SFCs)', () => {
142 | itWithData(emptyRenderValues, 'when a component returns: ', (data) => {
143 | function Foo() {
144 | return data.value;
145 | }
146 | const wrapper = Wrap(
156 |
160 | );
161 | }
162 | }
163 |
164 | const wrapper = WrapRendered(
;
14 | }
15 | }
16 | class Bar extends React.Component {
17 | render() {
18 | const { render: r } = this.props;
19 | return {typeof r === 'function' && r()}
;
20 | }
21 | }
22 | class RendersBar extends React.Component {
23 | render() {
24 | return
31 |
(
33 |
34 |
36 | )}
37 | />
38 |
45 |
,
47 | );
48 | const renderPropWrapperB = wrapperB.find(Bar).renderProp('render')();
49 | expect(renderPropWrapperB.find(Foo)).to.have.lengthOf(1);
50 |
51 | const stub = vi.fn().mockReturnValue(
);
52 | const wrapperC = Wrap(
53 |
54 |
,
56 | );
57 | stub.mockClear();
58 | wrapperC.find(Bar).renderProp('render')('one', 'two');
59 | expect(stub.mock.calls).to.deep.equal([['one', 'two']]);
60 | });
61 |
62 | it('throws on a non-string prop name', () => {
63 | const wrapper = Wrap( {}} />);
64 | expect(() => wrapper.renderProp()).to.throw(
65 | TypeError,
66 | `${WrapperName}::renderProp(): \`propName\` must be a string`,
67 | );
68 | });
69 |
70 | it('throws on a missing prop', () => {
71 | const wrapper = Wrap( {}} />);
72 | expect(() => wrapper.renderProp('nope')).to.throw(
73 | Error,
74 | `${WrapperName}::renderProp(): no prop called “nope“ found`,
75 | );
76 | });
77 |
78 | it('throws on a non-function render prop value', () => {
79 | const wrapper = Wrap({children}
;
91 | }
92 | }
93 |
94 | const wrapper = WrapRendered(
);
95 | expect(wrapper.is('div')).to.equal(true);
96 | expect(() => wrapper.renderProp('foo')).to.throw();
97 | });
98 |
99 | wrap()
100 | .withOverride(
101 | () => getAdapter(),
102 | 'wrap',
103 | () => undefined,
104 | )
105 | .it('throws with a react adapter that lacks a `.wrap`', () => {
106 | const wrapper = Wrap(
107 |
108 |
(
110 |
111 |
113 | )}
114 | />
115 | x} />;
123 | }
124 |
125 | function ComponentWithRenderProp({ val, r }) {
126 | return r(val);
127 | }
128 |
129 | it('works with strings', () => {
130 | const wrapper = Wrap(