程序代写 Chapter 1

UNIT TESTING HELPS SPLIT THE CODE INTO INDEPENDENT DECOUPLED PIECES AND MAKE SURE THEY JUST WORKTM.

IT HELPS BE CONFIDENT THAT EVERY CLASS, MODULE OR COMPONENT IS STABLE ENOUGH AND HAS A PREDICTABLE AND WELL-DEFINED BEHAVIOUR.

UNIT TESTS ARE BASICALLY A PROGRAMMED SPECIFICATION OF A COMPONENT’S BEHAVIOUR, AND THEY WILL FAIL IF COMPONENT BEHAVIOUR ACCIDENTALLY CHANGES.
IT GETS EXTREMELY CONVENIENT WHEN WE WANT TO REFACTOR A MODULE AND MAKE SURE ITS PUBLIC API AND REMAINS UNCHANGED.

WHEN SOFTWARE MODULES AND COMPONENTS ARE PROPERLY UNIT TESTED, IT REALLY FEELS EASIER AND MORE CONFIDENT TO BUILD SOFTWARE OUT OF THESE PIECES, KNOWING THAT THEY (MOST LIKELY) WON’T ACT UNEXPECTEDLY.

UNIT TESTING DOES SCALE VERY WELL.

UNIT TESTS RUN VERY FAST, DON’T HAVE SPECIAL REQUIREMENTS FOR THE ENVIRONMENT, CAN BE LAUNCHED FROM EVERYWHERE, INCLUDING A DEVELOPER’S LAPTOP.

UNIT TESTS EVEN CAN BE AUTO-RUN FOR EVERY COMMIT THAT GETS PUSHED IN THE REPO, AND CAN BLOCK PULL REQUEST FROM GETTING MERGE IF THERE IS ANY REGRESSION.

UNIT TESTS HELP DISCOVER REGRESSIONS VERY QUICKLY AND ENCOURAGE FIXING UP REGRESSIONS IN A CONCISE TIME.

PLEASE WRITE UNIT TESTS
It is a skill a professional software engineer must master.
It might feel difficult or unnecessary, and it does have a learning curve, but in long term, it’s such a timesaver.

UNIT-TESTING A MODULE THAT HAS
TOO MANY IMPLICIT DEPENDENCIES AND CONTAINS TOO MUCH LOGIC CAN BE DIFFICULT. THAT’S WHY UNIT TESTING ENCOURAGES TIMELY REFACTORING.

IT HELPS SPLIT COMPLEX LOGIC INTO SMALLER PIECES, DECOUPLE THE CODE AND REDUCE IMPLICIT DEPENDENCIES. IT MAKES THE ARCHITECTURE OF AN ENTIRE SOFTWARE PRODUCT BETTER.

WE’LL SPEAK A BIT MORE ABOUT HOW TO WRITE UNIT TESTS, THE TDD, AND BEST PRACTICES OF UNIT TESTING IN THE DEMO SECTION OF THIS PRESENTATION.

UNIT TESTING!
UNIT TESTING!
UNIT TESTING!

yourcoolprooject – – -zsh – 100×40
~/yourcoolproject (master) $ npm run test:integration
PASS src/main.test.js (6.522s) Main Page
Renders header, description, and gray area
Shows the image after clicking the button
Shows “Hi” text next to image after 5 seconds
Doesn’t show the image when can’t load it
Test Suites: 1 passed, 1 total
Snapshots:
Ran all test suites.
✨ Done in 8.655s.
~/projects/yourcoolproject (master) $
4 passed, 4 total 0 total
INTEGRATION TESTING
Unit testing helps
check every component
or module separately;
however, it doesn’t
guarantee the
correctness of the
application.
Even though our ‘legos’
work well separately,
the code that binds
them together can still

yourcoolprooject – – -zsh – 100×40
~/yourcoolproject (master) $ npm run test:integration
PASS src/main.test.js (6.522s) Main Page
Renders header, description, and gray area
Shows the image after clicking the button
Shows “Hi” text next to image after 5 seconds
Doesn’t show the image when can’t load it
Test Suites: 1 passed, 1 total
Snapshots:
Ran all test suites.
✨ Done in 8.655s.
~/projects/yourcoolproject (master) $
4 passed, 4 total 0 total
INTEGRATION TESTING
Manual testing solves
that sort of issues,
but as we proved
earlier, it doesn’t
scale well.
Integration testing
implies running a web
browser or a browser-
like runtime and
programmatically
triggering
functionality.

INTEGRATION TESTING IS USUALLY MOVE ‘HEAVY’ AND TIME-CONSUMING THAN UNIT TESTING.
THEY’RE SLOWER TO RUN, THEY’RE A
BIT MORE DIFFICULT TO WRITE, AND SOMETIMES, THEY MAY BE A BIT MORE ‘FLAKY’.

HOWEVER, YOU CAN’T GUARANTEE THAT THE ENTIRE SYSTEM WORKS, WITHOUT RUNNING IT AND CHECKING THAT ALL THE PIECES INTEROP PROPERLY.

INTEGRATION TESTING HELPS MAKE SURE A SOFTWARE PRODUCT IS CONSISTENT AND FEATURES ARE PROPERLY IMPLEMENTED.

INTEGRATION TESTING CAN USE A REAL DOM (IN A REAL WEB BROWSER) OR A FAKE/PROGRAMMATIC DOM (LIKE JSDOM).

REAL DOM TESTING PROVIDES A MORE ACCURATE RESULT. HOWEVER, BROWSERS ARE HEAVY, SLOWER TO RUN, AND SOMETIMES, SUCH TESTS MAY BE FLAKIER.

TESTING WITH A FAKE DOM IS USUALLY EASIER, AND SUCH TESTS ARE A LOT FASTER TO RUN. HOWEVER, FAKE DOM IMPLEMENTATIONS DON’T SUPPORT ALL THE DOM FEATURES THAT BROWSERS DO.

WHAT TO CHOOSE FOR INTEGRATION TESTING? REAL DOM OR FAKE DOM?

IT DEPENDS.
IN MOST CASES, USING A FAKE DOM IS SUFFICIENT.

WITH A FAKE DOM, YOU DON’T NEED A WEB BROWSER. YOU JUST NEED NODE.JS, AND A TEST LIBRARY WITH DOM SUPPORT (E.G. JEST+JSDOM).
THESE TESTS ARE GENERALY MORE RELIABLE, AND IT’S EASIER TO MOCK NETWORK REQUESTS AND EXTERNAL DEPENDENCIES.

“640KB OUGHT TO BE ENOUGH FOR ANYBODY”

WE’LL DISCUSS THE INTEGRATION TESTING IN MORE DETAIL IN THE DEMO SECTION.

https://staging.yourcoolproject.com/
VERY IMPORTANT SOFTWARE
Click the button below to see a funny cat.
UI TESTING
UI testing simulates a
user’s activity. A UI
testing suite runs a
full-featured web
browser like Chrome
(sometimes, a headless
Chrome), and interacts
with the elements on
the screen. These
interactions are
programmatically.

UI TESTING IS ABOUT RUNNING REAL USER FLOWS IN A REAL WEB BROWSER.
IT’S PRETTY SIMILAR TO HOW MANUAL TESTING IS DONE… EXCEPT FOR BEING AUTOMATED.

UI TESTING MAY BE DIFFICULT, AND SOMETIMES, UI TESTS ARE HARD TO MAINTAIN.

YOU HAVE TO FIND AN ELEMENT ON THE
PAGE BY ITS XPATH OR CSS SELECTOR
AND TRIGGER AN EVENT ON THIS
THEN, YOU HAVE TO WAIT FOR THE UI TO UPDATE OR REACT, AND CHECK THAT WHATEVER WAS SUPPOSED TO HAPPEN HAS HAPPENED.

TOOLS LIKE CYPRESS OR SELENIUM HELP ORGANIZE PROPER UI TESTING AND PROVIDE HELPERS FOR MAKING THE TESTING PROCESS EASIER.
HOWEVER, SOMETIMES, UI TESTING IS
STILL A PRETTY PAINFUL THING.

ONE OF THE REASONS FOR THAT IS
HAVING TO USE CSS SELECTORS.

GENERATED HTML STRUCTURE/DOM IS A
‘PRIVATE’ THING THAT CAN BE CHANGED
AT ANY TIME, WITH NO VISUAL CHANGES
NOTICEABLE TO USERS.
HOWEVER, EVEN THOUGH UI TESTING
IMPLIES USER FLOW TESTING, WE HAVE
TO RELY ON THESE ‘PRIVATE’
IMPLEMENTATION DETAILS DUE TO THE
PROGRAMMATIC NATURE OF UI TESTING.

EVEN THOUGH UI TESTING MAY BE HARD,
IT IS EXTREMELY IMPORTANT.
WE SHIP SOFTWARE TO BE USED BY
PEOPLE, AND WE MUST MAKE SURE THEY
CAN USE IT IN THE DESIGNED WAY.

WE’LL DISCUSS UI TESTING AND HOW TO
SET IT UP IN THE NEXT LECTURE.

TESTING PYRAMID
The classic ‘testing pyramid’ looks like this →

TESTING PYRAMID
The basis of the
pyramid is unit tests.
They are easy to write
and are fast to run,
and they help keep
modules stable and the
software architecture

TESTING PYRAMID
In the middle, there
are integration tests.
They are a bit harder
to write but they are
still pretty fast to
run (especially with
fake DOM).
They can help ensure
that modules work
perfectly together.

TESTING PYRAMID
On the top, there are
They are UI-focused and
user flow-focused, and
they help make sure
that from the user’s
perspective, everything
will work exactly as we
want it to work.
They’re slower, harder
to maintain, and
require running a real
web browser.

TESTING PYRAMID
Separately and higher
than the pyramid
itself, there are
manual tests.
Sometimes, you just
have to test the
software manually.
The main point is to
maintain enough unit,
integration, and UI
tests to keep the
manual testing to the

TESTING IS IMPORTANT
Testing saves time on
debugging and helps
avoid or reduce the
user suffering.
Software may be hard to
use, and it’s even
harder when it doesn’t
work properly.

LET’S UNIT TEST A REACT COMPONENT WITH JEST AND REACT TESTING LIBRARY
HTTPS://JESTJS.IO/ HTTPS://TESTING-LIBRARY.COM

LET’S WRITE SOME INTEGRATION TESTS FOR THE PAGE WITH A CAT IMAGE
HTTPS://JESTJS.IO/ HTTPS://GITHUB.COM/JSDOM/JSDOM

程序代写 CS代考 加微信: powcoder QQ: 1823890830 Email: powcoder@163.com