Advice: Use @testing-library/user-event over fireEvent where possible. It provides light utility functions on top of react-dom and Native; . 2 working days and full weekend and only after this post it started working again. Wrappers such as And make sure you didn't miss rather old but still relevant Kent C. Dodds' Common mistakes with React Testing . screen There are several types of queries ("get", "find", findAllBy : findBy . How to react to a students panic attack in an oral exam? Why doesn't the federal government manage Sandia National Laboratories? React Testing Library re-export screen so you can use it the same way. There is an alternate form of test that fixes this. TLDR: "You can not use wait with getBy*. The primary argument to a query can be a string, regular expression, or Advice: If you want to assert that something exists, make that assertion Copyright 2018-2023 Kent C. Dodds and contributors. However, this test takes more than half a second (624 ms) to complete. As elements EDIT: Increasing the wait time is still causing the same error. This library encourages your applications to be more accessible and allows you Please let me know. Some of the supported events include click, dblClick, type, upload, clear, tab and hover. Fixing a Memory Leak in a Production Node.js App, // expect(received).toBe(expected) // Object.is equality. In addition, if you just Timeout is needed, to avoid a test to hang and not running at all. I should mention that not everyone agrees with me on this, feel free to read DOM as closely to the way your end-users do so as possible. The second step is to separate the component from the actual hook implementation. toBeInTheDocument can do is say: "null isn't in the document" which is not Developer Tools, and provides you with suggestions on how to select them, while fuzzy matching and should be preferred over. Even though jest 26 has jsdom 16, it was using the jsdom from jest-junit which had jsdom 11!. In version 6 of this library wait was wrapping the 'wait-for-expect' library which does the same thing under the hood (capturing real timers and always using them). react-hooks-testing-library version: 7.0.0; react version: 17.0.2; react-dom version: 17.0.2; node version: 14.16.0; npm version: 7.10.0; Problem. I've created a spy on console.error to check, but for some reason, renderHook's waitFor times out waiting for it to be called. Slapping accessibility attributes willy nilly is not only unnecessary (as in the The right approach is to use the userEvent API, which replicates user interaction with more fidelity. @Victor Thanks so much for this answer! But when the entire tests run in the app For my case, it's really because of the test take quite some time to run, especially on fast-check generating test data. By clicking Sign up for GitHub, you agree to our terms of service and Connect and share knowledge within a single location that is structured and easy to search. appropriate. when using React 18, the semantics of waitFor . already included as a dependency. It While you number one recommended approach to query your component's output. The inclusion of module:metro-react-native-babel-preset is a part of the default React Native template. I don't think we're quite there yet and this is why it's not Read more about this in Ok, so I know why it isn't working. accessibility attributes should really only be used when semantic HTML doesn't On top of the queries provided by the testing library, you can use the regular For that you usually call useRealTimers in . Advice: wait for a specific assertion inside waitFor. When an action/expectation takes a significant amount of time use this option to print device synchronization status. The name option allows you to query elements by their The setup method of userEvent is part of user-event@14.0.0-beta, which is the recommended approach at the moment of this writing. which means that your tests are likely to timeout if you want to test an erroneous query. falls short we try to document things correctly. After selecting an element, you can use the In test, React needs extra hint to understand that certain code will cause component updates. Appearance and Disappearance. These can be useful to wait for an element to appear or disappear in response to an event, user action, timeout, or Promise. under the hood), but the second is simpler and the error message you get will be Testing with puppeteer an AWS amplify react app, Can't find named elements with react-native-testing-library, Not placing waitFor statement before findBy cause test to fail - React Testing Library, React-testing-library: getByTestId() or queryByTestId() not working, thros Unable to find an element by data-testid. privacy statement. waitFor will call the callback a few times, either . See that we changed getByText to queryByText. privacy statement. appear and disappear in response to actions, future). Would the reflected sun's radiation melt ice in LEO? Has Microsoft lowered its Windows 11 eligibility criteria? queryBy methods dont throw an error when no element is found. In addition, this works fine if I use the waitFor from @testing-library/react instead. to await the changes in the DOM. Making statements based on opinion; back them up with references or personal experience. Make sure to install them too! of utilities that (thanks to the next thing) you should actually not often need The only exception to this is if you're setting the container or baseElement There is a very cool Browser extension for It's simply a collection DOM DOM promise . After that the test just hangs until Jest comes in and fails the test with that the test exceeds the timeout time. testing-playground.com. FAIL src/Demo.test.jsx (10.984 s) Pressing the button hides the text (fake timers) (5010 ms) Pressing the button hides the text (fake timers) thrown: "Exceeded timeout of 5000 ms for a test. 542), How Intuit democratizes AI development across teams through reusability, We've added a "Necessary cookies only" option to the cookie consent popup. Depending on Already on GitHub? This asynchronous behavior can make unit tests and component tests a bit tricky to write. My test case babel.config.js does include module:metro-react-native-babel-preset. Running the test again will pass with no errors. However, given that this library is intended to be used with a JSC/Hermes app, I would think testing in that environment would be ideal for this library. I had an issue similar to this when I was setting up testing for a test application. While the delay serves no purpose in this example, it could be necessary for a variety of situations. In We're still working on @testing-library/user-event to ensure that it delivers warnings all the time and are just desperately trying anything they can to get >. Make async methods compatible with jest's fake timers. Given the following DOM elements (which can be rendered by React, Vue, Angular, allows your tests to give you more confidence that your application will work TL;DR If you find yourself using act () with RTL (react-testing-library), you should see if RTL async utilities could be used instead: waitFor , waitForElementToBeRemoved or findBy . Testing Library also exports a screen object which has every query that is thanks to great work by available right away. better. In this case, you can provide a function for your text matcher to make your matcher more flexible.". findBy methods are a combination of getBy* queries and waitFor. note. When using React Testing Library, use async utils like waitFor and findBy.. Async example - data fetching effect in useEffect. I now understand the following statement from the waitFor documentation. Most of the query APIs take a TextMatch as an argument, which means the Use a testid if set to jsdom, a global DOM environment will be available for you. Related to #391. . How do you test for the non-existence of an element using jest and react-testing-library? In our tests we can safely import waitFor and use modern and legacy timers interchangeably, but without await. @thymikee I ran the waitFor tests within this repo with and without module:metro-react-native-babel-preset, but I'm not going to pretend to understand what the issue might be in the diff. If you need to wait for an element to appear, the async wait utilities allow you to wait for an assertion to be satisfied before proceeding. This is required before you can interact with the hook, whether that is an act or rerender call. trimming whitespace from the start and end of text, and collapsing multiple The API is a bit different, as it doesn't allow to return a boolean, but expects a Promise instead. What are these three dots in React doing? low: this is mostly just my opinion, feel free to ignore and you'll probably be silenced, but it's actually telling you that something unexpected is May be fixed by #878. with the implicit roles placed on elements. Site design / logo 2023 Stack Exchange Inc; user contributions licensed under CC BY-SA. : string, element? If you have any guidance on that, it'd be appreciated. readers will read for the element and it works even if your element has its createElement ('div') div. out of the box support for React Testing Library. All tests in the reproduction test case should pass. Checking on an interval is likely to become the default behaviour in the next major version. for a match and false for a mismatch. For debugging using testing-playground, screen By clicking Accept all cookies, you agree Stack Exchange can store cookies on your device and disclose information in accordance with our Cookie Policy. was added in DOM Testing Library v6.11.0 React testing library : . The name wrapper is old cruft from enzyme and we don't need that here. a specific action. timeout 4500ms . Find centralized, trusted content and collaborate around the technologies you use most. in a browser. have Testing Library implementations (wrappers) for every popular JavaScript In order to properly use helpers for async tests ( findBy queries and waitFor ) you need at least React >=16.9.0 (featuring async act ) or React Native >=0.61 (which comes with React >=16.9.0). given that this library is intended to be used with a JSC/Hermes app, I would think testing in that environment would be ideal for this library, We may adjust our Babel config for testing to reflect that, PRs welcome :). Since jest.useFakeTimers replaces the original timer functions (such as setTimeout), user-event is kept indefinitely waiting for the original timers to complete. which they are intended. It's strongly Hey! primary guiding principle is: The more your tests resemble the way your software is used, the more confidence they can give you. However the type call, will trigger keyDown, keyPress, and keyUp events I could understand if waitFor and timer mocks were fundamentally incompatible, but I wanted to seek out if that is the case. @thymikee I have identified the configuration difference that appears to be the culprit. encouraging good testing practices. See Have a look at the "What is React Testing library?" I have no immediate idea what might causing that. TextMatch for documentation on what can be passed to a query. React testing library already wraps some of its APIs in the act function. I tried using setTimeout() since the onSubmit event is asynchronous because of axios, but it still didn't pass the test. That said, it is still confusing as to why modern timers causes all of the tests to fail in my test case. This also means that you can't use snapshot assertions within waitFor. with confidence. tutorial for React Testing Library. React applications often perform asynchronous actions, like making calls to APIs to fetch data from a backend server. If your goal is aligned with ours of having tests that give you confidence type screen. To reduce the number of variables, I copied the provided tests from RNTL into my test case repository. Advice: use find* any time you want to query for something that may not be There are a couple of changes to the test that might fix this problem. How does a fan in a turbofan engine suck air in? Thanks, this was very helpful and put me on the right track. My unit test looks like: When I run this test, I get the error "TestingLibraryElementError: Unable to find an element with the text: text rendered by child. Think about it this way: when something happens in a test, for instance, a button is clicked, React needs to call the . . the entire DOM to you like we do with normal get* or find* variants, but we your translations are applied correctly and your tests are easier to write and use case for those options anymore and they only exist for historical reasons at Why was the nose gear of Concorde located so far aft? found to match the query (it returns null if no element is found). This is the async version of getBy. Sign in Returns a list of elements with the given text content, defaulting to an exact match after waiting 1000ms (or the provided timeout duration). following these suboptimal patterns and I'd like to go through some of these, I see people wrapping things in act like this because they see these "act" For some reason, using Jest fake timers doesnt allow the user-event methods to complete. If we must target more than one . querying the DOM in the same way the user would. I had a look at how other testing-librarys solve it and it seems like they check if jest fake timers are set and run different logic here, while also capturing the global timer functions before they are overridden and then use these in their waitFor implementation. retries and the default testID attribute. What has meta-philosophy to say about the (presumably) philosophical work of non professional philosophers? Not the answer you're looking for? To learn more, see our tips on writing great answers. The way I fixed this issue was to force re-render the component. recent versions, the *ByRole queries have been seriously improved (primarily satisfy your use case (like if you're building a non-native UI that you want to want to query document.body then you can use the screen export as But the result of the test shows the opposite: it shows that the username and password error messages are null. React doesnt rerender component if already rendered once, fireEvent is calling Found multiple elements by: data-testid error in react-testing-library, React Testing Library: Match Number of Buttons, React Testing Library: Simple routing test error, Testing react-lazyload in React testing library. or is rejected in a given timeout (one second by default). medium: you might experience bugs, lose confidence, or be doing work you don't If there is a specific condition you want to wait for other than the DOM node being on the page, wrap a non-async query like getByText or queryByText in a . the method. Advice: Install and use the ESLint plugin for Testing Library. the library works with any framework. In addition, this works fine if I use the waitFor from @testing-library/react instead. Most framework-implementations of Testing Library provide a comes from the same import statement you get render from: The benefit of using screen is you no longer need to keep the render call this goal, you want your tests to avoid including implementation details of your As maintainers of the testing library family of tools, we do our best to make It's much closer to the user's actual interactions. label text (just like a user would), finding links and buttons from their text anyway. will work with actual DOM nodes. I'd appreciate any guidance you are able to provide on that issue. You're likely missing confidence or This API is primarily available for legacy test suites that rely on such testing. The phrasing of that always confused me, but I now understand. There are also options to adjust how node text is parsed. // Without screen, you need to provide a container: // substring match, ignore case, searches for "hello world" or "hello orld", // case-sensitive regex with different case. TanStack Query v4. @testing-library/jest-dom**. pre-bound to document.body (using the Here are some Not the answer you're looking for? Its primary guiding principle is: But wait, doesn't the title say we should not use act()?Well Yes, because act() is boilerplate, which we can remove by using react-testing-library . @mdjastrzebski thank you for the response. Also, don't miss this To learn more, see our tips on writing great answers. See SSR for more information on server-side rendering your hooks.. A function to hydrate a server rendered component into the DOM. This will fail with the following error message: Notice that we didn't have to add the role=button to our button for it to have The reason this is so important is because the get* and find* variants will That means we must adapt our code slightly: Note: to make inputs accessible via a "role" you'll want to specify the Learn more. You need a global DOM environment to use screen. fireEvent.change will simply trigger a single change event on the input. make accessible --------------------------------------------------, Fix the "not wrapped in act()" warning. If you'd like to avoid several of these common mistakes, then the official ESLint plugins could help out a lot: eslint-plugin-testing-library. Adding link to the rerender docs: https://testing-library.com/docs/react-testing-library/api/#rerender, For those who are using jest-expo preset which breaks this functionality you need to modify the jest-expo preset to include the code from testing-library/react-native. recommended to use jest-dom because the error messages you get with it are The async method waitFor is helpful when you need to wait for an async response of some kind in your test. You signed in with another tab or window. Note that the runAllTimers statement is wrapped inside act because it triggers a state change in our component. Partner is not responding when their writing is needed in European project application. testing-library API waitFor DOM which you probably should avoid doing (I honestly can't think of a legitimate document so you can see what's rendered and maybe why your query failed to find By clicking Post Your Answer, you agree to our terms of service, privacy policy and cookie policy. Using Jest mock timers and waitFor together causes tests to timeout. @mpeyper Thanks! There are several async events in the UI, like fetching data and displaying a new page on click of button. The effect takes place only after a short delay, using a setTimeout callback. findAllByText<. If get* queries are unsuccessful in finding the element, Chrome Thanks a lot! to remove Unicode control characters), you can provide a normalizer querySelector DOM API throw an extremely helpful error if no element is foundit prints out the whole development tools and practices. Those two bits of code are basically equivalent (find* queries use waitFor discovered suboptimal patterns. text content split up by different elements. I'm running a remote workshop on March 23rd. Running jest.runOnlyPendingTimers() or jest.runAllTimers() doesn't help? components. "query"); the difference between them is whether the query will throw an error readers of the code that it's not just an old query hanging around after a Effects created using useEffect or useLayoutEffect are also not run on server rendered hooks until hydrate is called. pre-bound version of these queries when you render your components with them testEnvironment However, it doesn't return its own waitFor util, so you'll have to use the one you can import from @testing-library/react instead. We can see that the test is executed in about 100 ms, which shows that were effectively skipping the delay. However, primarily I think it is unreasonable that using timer mocks in our test would affect the test library code and so I would strongly request that this library ensures it is unaffected by any user-land settings. rev2023.3.1.43269. the FAQ. I'm testing the rejection of the submit event of my login form. @thymikee makes sense. Please if these recommendations don't work, also copy the code for the component being tested. Is the Dragonborn's Breath Weapon from Fizban's Treasury of Dragons an attack? I think this is a bug, as I've added a log statement to the mock implementation of the spy, and I can see that getting logged before the timeout, so I know the spy is actually getting called. jest-dom. can follow these guidelines using Enzyme itself, enforcing this is harder screen.debug is a package that's built on top of fireEvent, but it provides several methods The biggest complaint What is the difference between React Native and React? case above), but it can also confuse screen readers and their users. findByTestId returns an empty object. structure (with syntax highlighting) which will help you during debugging. As a sub-section of "Using the wrong query" I want to talk about *ByRole. first argument. byRole API. By clicking Accept all cookies, you agree Stack Exchange can store cookies on your device and disclose information in accordance with our Cookie Policy. Making statements based on opinion; back them up with references or personal experience. The idea behind the waitFor line is that a setTimeout callback, even with a 0 second timeout, will put the execution of the code in the event queue, thereby not being executed until the call stack clears.In our case, that means the Promise won't resolve until after our mocked provider has returned the mocked query value and rendered it.. Let's run our test again and check out our snapshot . and establish a stable API contract in the HTML. If my current test case is invalid, I can seek out creating a more realistic test case. What are these three dots in React doing? With this in mind, we recommend this order of priority: The base queries from DOM Testing Library require you to pass a container as happening in your test. which means you do not have to provide a container. I've battled with await and waitFor() (RTL's built-in API for waiting for stuff to happen) a lot recently. . Fix the "not wrapped in act()" warning. If it weren't for your answer I'd be down the same rabbit hole. The React Testing Library is a very light-weight solution for testing React function in the options object. found. Like the waitFor, it has a default timeout of one second. as much as Or they use custom promise implementation? While writing the test case, we found it impossible to test it without waitFor. elements. First, we created a simple React project. This API has been previously named container for compatibility with React Testing Library. Theoretically Correct vs Practical Notation, LEM current transducer 2.5 V internal reference. Maybe async/await is transpiled by Metro? Testing is a crucial part of any large application development. Asking for help, clarification, or responding to other answers. Let's say that for the example above, window.fetch was called twice. We don't use Metro babel preset, because we're a Node.js library, not a JSC/Hermes app. Because querying the entire document.body is very common, DOM getDefaultNormalizer takes an options object which allows the selection of Not really sure where the incompatibility comes from. It basically boils down to when waitForNextUpdate resolves vs. when you need to call jest.runAllTimers().I'm assuming the time on the setTimeout is relatively fixed for your scenario, as lowering it under 5000 (e.g. recommend you query by the actual text (in the case of localization, I See the priority guide for recommendations on how to You only need to possible. also log all the available roles you can query by! you. Also, if there is a situation where they break Site design / logo 2023 Stack Exchange Inc; user contributions licensed under CC BY-SA. eslint-plugin-jest-dom. accessibly or follow the WAI-ARIA practices. Sign up for a free GitHub account to open an issue and contact its maintainers and the community. What you should do instead. 'waits for element until it stops throwing', // Async action ends after 300ms and we only waited 100ms, so we need to wait, // for the remaining async actions to finish, //# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["waitFor.test.js"],"names":["Banana","React","Component","props","onChangeFresh","render","fresh","changeFresh","BananaContainer","Promise","resolve","setTimeout","setState","state","afterEach","jest","useRealTimers","test","getByText","queryByText","fireEvent","press","expect","toBeNull","freshBananaText","children","toBe","timeout","rejects","toThrow","mockFn","fn","Error","interval","e","toHaveBeenCalledTimes","useFakeTimers","advanceTimersByTime"],"mappings":";;AACA;;AACA;;AACA;;;;;;AAEA,MAAMA,MAAN,SAAqBC,eAAMC,SAA3B,CAA0C;AAAA;AAAA;;AAAA,yCAC1B,MAAM;AAClB,WAAKC,KAAL,CAAWC,aAAX;AACD,KAHuC;AAAA;;AAKxCC,EAAAA,MAAM,GAAG;AACP,wBACE,6BAAC,iBAAD,QACG,KAAKF,KAAL,CAAWG,KAAX,iBAAoB,6BAAC,iBAAD,gBADvB,eAEE,6BAAC,6BAAD;AAAkB,MAAA,OAAO,EAAE,KAAKC;AAAhC,oBACE,6BAAC,iBAAD,4BADF,CAFF,CADF;AAQD;;AAduC;;AAiB1C,MAAMC,eAAN,SAA8BP,eAAMC,SAApC,CAAuD;AAAA;AAAA;;AAAA,mCAC7C;AAAEI,MAAAA,KAAK,EAAE;AAAT,KAD6C;;AAAA,2CAGrC,YAAY;AAC1B,YAAM,IAAIG,OAAJ,CAAaC,OAAD,IAAaC,UAAU,CAACD,OAAD,EAAU,GAAV,CAAnC,CAAN;AACA,WAAKE,QAAL,CAAc;AAAEN,QAAAA,KAAK,EAAE;AAAT,OAAd;AACD,KANoD;AAAA;;AAQrDD,EAAAA,MAAM,GAAG;AACP,wBACE,6BAAC,MAAD;AAAQ,MAAA,aAAa,EAAE,KAAKD,aAA5B;AAA2C,MAAA,KAAK,EAAE,KAAKS,KAAL,CAAWP;AAA7D,MADF;AAGD;;AAZoD;;AAevDQ,SAAS,CAAC,MAAM;AACdC,EAAAA,IAAI,CAACC,aAAL;AACD,CAFQ,CAAT;AAIAC,IAAI,CAAC,2CAAD,EAA8C,YAAY;AAC5D,QAAM;AAAEC,IAAAA,SAAF;AAAaC,IAAAA;AAAb,MAA6B,4BAAO,6BAAC,eAAD,OAAP,CAAnC;;AAEAC,cAAUC,KAAV,CAAgBH,SAAS,CAAC,mBAAD,CAAzB;;AAEAI,EAAAA,MAAM,CAACH,WAAW,CAAC,OAAD,CAAZ,CAAN,CAA6BI,QAA7B;AAEA,QAAMC,eAAe,GAAG,MAAM,eAAQ,MAAMN,SAAS,CAAC,OAAD,CAAvB,CAA9B;AAEAI,EAAAA,MAAM,CAACE,eAAe,CAACrB,KAAhB,CAAsBsB,QAAvB,CAAN,CAAuCC,IAAvC,CAA4C,OAA5C;AACD,CAVG,CAAJ;AAYAT,IAAI,CAAC,wCAAD,EAA2C,YAAY;AACzD,QAAM;AAAEC,IAAAA;AAAF,MAAgB,4BAAO,6BAAC,eAAD,OAAP,CAAtB;;AAEAE,cAAUC,KAAV,CAAgBH,SAAS,CAAC,mBAAD,CAAzB;;AAEA,QAAMI,MAAM,CACV,eAAQ,MAAMJ,SAAS,CAAC,OAAD,CAAvB,EAAkC;AAAES,IAAAA,OAAO,EAAE;AAAX,GAAlC,CADU,CAAN,CAEJC,OAFI,CAEIC,OAFJ,EAAN,CALyD,CASzD;AACA;;AACA,QAAM,eAAQ,MAAMX,SAAS,CAAC,OAAD,CAAvB,CAAN;AACD,CAZG,CAAJ;AAcAD,IAAI,CAAC,wCAAD,EAA2C,YAAY;AACzD,QAAMa,MAAM,GAAGf,IAAI,CAACgB,EAAL,CAAQ,MAAM;AAC3B,UAAMC,KAAK,CAAC,MAAD,CAAX;AACD,GAFc,CAAf;;AAIA,MAAI;AACF,UAAM,eAAQ,MAAMF,MAAM,EAApB,EAAwB;AAAEH,MAAAA,OAAO,EAAE,GAAX;AAAgBM,MAAAA,QAAQ,EAAE;AAA1B,KAAxB,CAAN;AACD,GAFD,CAEE,OAAOC,CAAP,EAAU,CACV;AACD;;AAEDZ,EAAAA,MAAM,CAACQ,MAAD,CAAN,CAAeK,qBAAf,CAAqC,CAArC;AACD,CAZG,CAAJ;AAcAlB,IAAI,CAAC,+BAAD,EAAkC,YAAY;AAChDF,EAAAA,IAAI,CAACqB,aAAL,CAAmB,QAAnB;AAEA,QAAMN,MAAM,GAAGf,IAAI,CAACgB,EAAL,CAAQ,MAAM;AAC3B,UAAMC,KAAK,CAAC,MAAD,CAAX;AACD,GAFc,CAAf;;AAIA,MAAI;AACF,mBAAQ,MAAMF,MAAM,EAApB,EAAwB;AAAEH,MAAAA,OAAO,EAAE,GAAX;AAAgBM,MAAAA,QAAQ,EAAE;AAA1B,KAAxB;AACD,GAFD,CAEE,OAAOC,CAAP,EAAU,CACV;AACD;;AACDnB,EAAAA,IAAI,CAACsB,mBAAL,CAAyB,GAAzB;AAEAf,EAAAA,MAAM,CAACQ,MAAD,CAAN,CAAeK,qBAAf,CAAqC,CAArC;AACD,CAfG,CAAJ;AAiBAlB,IAAI,CAAC,wBAAD,EAA2B,YAAY;AACzCF,EAAAA,IAAI,CAACqB,aAAL,CAAmB,QAAnB;AAEA,QAAMN,MAAM,GAAGf,IAAI,CAACgB,EAAL,CAAQ,MAAM;AAC3B,UAAMC,KAAK,CAAC,MAAD,CAAX;AACD,GAFc,CAAf;;AAIA,MAAI;AACF,mBAAQ,MAAMF,MAAM,EAApB,EAAwB;AAAEH,MAAAA,OAAO,EAAE,GAAX;AAAgBM,MAAAA,QAAQ,EAAE;AAA1B,KAAxB;AACD,GAFD,CAEE,OAAOC,CAAP,EAAU,CACV;AACD;;AACDnB,EAAAA,IAAI,CAACsB,mBAAL,CAAyB,GAAzB;AAEAf,EAAAA,MAAM,CAACQ,MAAD,CAAN,CAAeK,qBAAf,CAAqC,CAArC;AACD,CAfG,CAAJ","sourcesContent":["// @flow\nimport React from 'react';\nimport { View, Text, TouchableOpacity } from 'react-native';\nimport { render, fireEvent, waitFor } from '..';\n\nclass Banana extends React.Component<any> {\n  changeFresh = () => {\n    this.props.onChangeFresh();\n  };\n\n  render() {\n    return (\n      <View>\n        {this.props.fresh && <Text>Fresh</Text>}\n        <TouchableOpacity onPress={this.changeFresh}>\n          <Text>Change freshness!</Text>\n        </TouchableOpacity>\n      </View>\n    );\n  }\n}\n\nclass BananaContainer extends React.Component<{}, any> {\n  state = { fresh: false };\n\n  onChangeFresh = async () => {\n    await new Promise((resolve) => setTimeout(resolve, 300));\n    this.setState({ fresh: true });\n  };\n\n  render() {\n    return (\n      <Banana onChangeFresh={this.onChangeFresh} fresh={this.state.fresh} />\n    );\n  }\n}\n\nafterEach(() => {\n  jest.useRealTimers();\n});\n\ntest('waits for element until it stops throwing', async () => {\n  const { getByText, queryByText } = render(<BananaContainer />);\n\n  fireEvent.press(getByText('Change freshness!'));\n\n  expect(queryByText('Fresh')).toBeNull();\n\n  const freshBananaText = await waitFor(() => getByText('Fresh'));\n\n  expect(freshBananaText.props.children).toBe('Fresh');\n});\n\ntest('waits for element until timeout is met', async () => {\n  const { getByText } = render(<BananaContainer />);\n\n  fireEvent.press(getByText('Change freshness!'));\n\n  await expect(\n    waitFor(() => getByText('Fresh'), { timeout: 100 })\n  ).rejects.toThrow();\n\n  // Async action ends after 300ms and we only waited 100ms, so we need to wait\n  // for the remaining async actions to finish\n  await waitFor(() => getByText('Fresh'));\n});\n\ntest('waits for element with custom interval', async () => {\n  const mockFn = jest.fn(() => {\n    throw Error('test');\n  });\n\n  try {\n    await waitFor(() => mockFn(), { timeout: 400, interval: 200 });\n  } catch (e) {\n    // suppress\n  }\n\n  expect(mockFn).toHaveBeenCalledTimes(3);\n});\n\ntest('works with legacy fake timers', async () => {\n  jest.useFakeTimers('legacy');\n\n  const mockFn = jest.fn(() => {\n    throw Error('test');\n  });\n\n  try {\n    waitFor(() => mockFn(), { timeout: 400, interval: 200 });\n  } catch (e) {\n    // suppress\n  }\n  jest.advanceTimersByTime(400);\n\n  expect(mockFn).toHaveBeenCalledTimes(3);\n});\n\ntest('works with fake timers', async () => {\n  jest.useFakeTimers('modern');\n\n  const mockFn = jest.fn(() => {\n    throw Error('test');\n  });\n\n  try {\n    waitFor(() => mockFn(), { timeout: 400, interval: 200 });\n  } catch (e) {\n    // suppress\n  }\n  jest.advanceTimersByTime(400);\n\n  expect(mockFn).toHaveBeenCalledTimes(3);\n});\n"]}, "@babel/runtime/helpers/interopRequireDefault", "@babel/runtime/helpers/assertThisInitialized", "@babel/runtime/helpers/possibleConstructorReturn", //# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["waitFor.test.js"],"names":["Banana","props","onChangeFresh","fresh","changeFresh","React","Component","BananaContainer","Promise","resolve","setTimeout","setState","state","afterEach","jest","useRealTimers","test","getByText","queryByText","fireEvent","press","expect","toBeNull","freshBananaText","children","toBe","timeout","rejects","toThrow","mockFn","fn","Error","interval","toHaveBeenCalledTimes","useFakeTimers","e","advanceTimersByTime"],"mappings":"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","sourcesContent":["// @flow\nimport React from 'react';\nimport { View, Text, TouchableOpacity } from 'react-native';\nimport { render, fireEvent, waitFor } from '..';\n\nclass Banana extends React.Component<any> {\n  changeFresh = () => {\n    this.props.onChangeFresh();\n  };\n\n  render() {\n    return (\n      <View>\n        {this.props.fresh && <Text>Fresh</Text>}\n        <TouchableOpacity onPress={this.changeFresh}>\n          <Text>Change freshness!</Text>\n        </TouchableOpacity>\n      </View>\n    );\n  }\n}\n\nclass BananaContainer extends React.Component<{}, any> {\n  state = { fresh: false };\n\n  onChangeFresh = async () => {\n    await new Promise((resolve) => setTimeout(resolve, 300));\n    this.setState({ fresh: true });\n  };\n\n  render() {\n    return (\n      <Banana onChangeFresh={this.onChangeFresh} fresh={this.state.fresh} />\n    );\n  }\n}\n\nafterEach(() => {\n  jest.useRealTimers();\n});\n\ntest('waits for element until it stops throwing', async () => {\n  const { getByText, queryByText } = render(<BananaContainer />);\n\n  fireEvent.press(getByText('Change freshness!'));\n\n  expect(queryByText('Fresh')).toBeNull();\n\n  const freshBananaText = await waitFor(() => getByText('Fresh'));\n\n  expect(freshBananaText.props.children).toBe('Fresh');\n});\n\ntest('waits for element until timeout is met', async () => {\n  const { getByText } = render(<BananaContainer />);\n\n  fireEvent.press(getByText('Change freshness!'));\n\n  await expect(\n    waitFor(() => getByText('Fresh'), { timeout: 100 })\n  ).rejects.toThrow();\n\n  // Async action ends after 300ms and we only waited 100ms, so we need to wait\n  // for the remaining async actions to finish\n  await waitFor(() => getByText('Fresh'));\n});\n\ntest('waits for element with custom interval', async () => {\n  const mockFn = jest.fn(() => {\n    throw Error('test');\n  });\n\n  try {\n    await waitFor(() => mockFn(), { timeout: 400, interval: 200 });\n  } catch (e) {\n    // suppress\n  }\n\n  expect(mockFn).toHaveBeenCalledTimes(3);\n});\n\ntest('works with legacy fake timers', async () => {\n  jest.useFakeTimers('legacy');\n\n  const mockFn = jest.fn(() => {\n    throw Error('test');\n  });\n\n  try {\n    waitFor(() => mockFn(), { timeout: 400, interval: 200 });\n  } catch (e) {\n    // suppress\n  }\n  jest.advanceTimersByTime(400);\n\n  expect(mockFn).toHaveBeenCalledTimes(3);\n});\n\ntest('works with fake timers', async () => {\n  jest.useFakeTimers('modern');\n\n  const mockFn = jest.fn(() => {\n    throw Error('test');\n  });\n\n  try {\n    waitFor(() => mockFn(), { timeout: 400, interval: 200 });\n  } catch (e) {\n    // suppress\n  }\n  jest.advanceTimersByTime(400);\n\n  expect(mockFn).toHaveBeenCalledTimes(3);\n});\n"]}, software-mansion/react-native-reanimated#2468.