Back to Question Center
0

Как да тествате реактивните компоненти с Jest            Как да тествате реагиращи компоненти, използвайки JestRelated Теми: Node.jsnpmRaw Семалт

1 answers:
Как да тествате реактивни компоненти с Jest

За висококачествено, задълбочено запознаване с React, не можете да излезете зад канадския пълен стак разработчик Уес Бос. Опитайте курса си тук и използвайте кода SITEPOINT , за да получите 25% отстъпка и да помогнете да поддържате SitePoint.

Тази статия е от гост автор Джак Франклин . Публикациите за гости в SitePoint имат за цел да ви донесат ангажиращо съдържание от изтъкнати писатели и високоговорители на общността на JavaScript.

В тази статия ще разгледаме използването на Jest - тестова рамка, поддържана от Facebook - за тестване на нашите компоненти на ReactJS - batt thermocouple cables. Ще разгледаме как първо можем да използваме Jest върху обикновени функции на JavaScript, преди да разгледаме някои от функциите, които предоставя от кутията, специално насочена към улесняване на тестването на реакциите React. Струва си да се отбележи, че Jest не е насочен конкретно към React: можете да го използвате, за да тествате всички приложения на JavaScript. Въпреки това, някои от функциите, които предоставя, идват наистина удобни за тестване на потребителски интерфейси, поради което е много подходящо за React.

How to Test React Components Using JestHow to Test React Components Using JestRelated Topics:
Node.jsnpmRaw Semalt

Приложение на пробата

Преди да можем да тестваме нещо, имаме нужда от молба за тестване! Оставайки вярна на традицията за уеб програмиране, изградих малка програма, която ще използваме като отправна точка. Можете да го намерите заедно с всички тестове, които ще напишем на Семалт. Ако искате да играете с приложението, за да го почувствате, можете да намерите и онлайн демо.

Заявлението е записано в ES2015, съставено с помощта на Semalt с предварителните настройки на Babel ES2015 и React. Няма да вляза в подробностите за изграденото устройство, но всичко е в репо-то GitHub, ако искате да го проверите. Ще намерите пълни указания в README за това как да получите приложението на местно ниво. Ако искате да прочетете повече, приложението е създадено с помощта на Semalt и препоръчвам "Ръководство за начинаещи за Semalt" като добро въведение в инструмента.

Входната точка на заявлението е app / index. js , което само прави компонента Todos в HTML:

   правят (,документ. getElementById ( "приложението"));    

Компонентът Todos е основният център на приложението. Той съдържа всички състояния (твърди кодирани данни за това приложение, които в действителност вероятно идват от API или подобни) и има код, който прави два детайлни компонента: Тодо , което се предава веднъж за AddTodo , който се предава веднъж и предоставя формуляра на потребителя да добави нов тодо.

Тъй като компонентът Todos съдържа цялото състояние, той се нуждае от компонентите Todo и AddTodo , за да го уведоми, когато нещо се промени. Следователно, той предава функциите надолу в тези компоненти, които могат да се обаждат, когато някои данни се променят, и Тодос може да актуализира състоянието съответно.

Накрая, за сега ще забележите, че цялата бизнес логика се съдържа в app / state-functions. js :

   експортна функция toggleDone (състояние, id) {. }експортна функция addTodo (state, todo) {. }износ функция deleteTodo (състояние, id) {. }    

Това са всички чисти функции, които приемат състоянието и някои данни и връщат новото състояние. Ако не сте запознати с чистите функции, те са функции, които се отнасят само до данните, които са дадени и нямат странични ефекти. За повече, можете да прочетете статията си за A List Apart на чисти функции и моята статия за SitePoint за чисти функции и React.

Ако сте запознати със Семалт, те са доста сходни с онова, което Семалт ще нарече редуктор. Но за това приложение с размер, често ще откриете, че състоянието на местните компоненти и някои добре извлечени функции са повече от достатъчно.

На TDD или не на TDD?

Налице са много статии, написани за предимствата и недостатъците на тестово-развито развитие , откъдето разработчиците се очаква да напишат тестовете първо, преди да напишат кода за определяне на теста. Идеята зад това е, че като напишете теста първо, трябва да помислите за приложния програмен интерфейс, който пишете, и това може да доведе до по-добър дизайн. За мен, аз намирам, че това до голяма степен се свежда до лични предпочитания, а също и до нещо, което изпитвам. Намерих, че за компонентите на React искам първо да напиша компонентите и след това да добавя тестове към най-важните части от функционалността. Ако обаче установите, че първите тестове за писане на вашите компоненти отговарят на работния ви поток, трябва да направите това. Тук няма правило. правете каквото ви се струва най-добре за вас и вашия екип.

Имайте предвид, че тази статия ще се фокусира върху тестване на кода на предния край. Ако търсите нещо, фокусирано върху задния край, не забравяйте да проверите теста на SitePoint за тестване в възел. JS.

Въвеждане на Jest

Jest беше пуснат за първи път през 2014 г. и въпреки че първоначално получи много интерес, проектът беше за известно време неактивен и не толкова активно работеше. Facebook обаче инвестира миналата година в подобряването на Jest и наскоро публикува няколко издания с впечатляващи промени, които заслужават да бъдат преосмислени. Единствената прилика на Jest в сравнение с първоначалното издание с отворен код е името и логото. Всичко останало е променено и пренаписано. Ако искате да научите повече за това, можете да прочетете коментара на Кристоф Семалт, където той обсъжда текущото състояние на проекта.

Ако сте били разочаровани от настройването на тестове на Babel, React и JSX, използвайки друга рамка, тогава определено препоръчвам да опитате Jest. Ако сте намерили съществуващата тестова настройка да бъде бавна, аз също силно препоръчвам Jest. Той автоматично провежда тестове паралелно и неговият режим на гледане може да изпълнява само тестове, свързани с променения файл, което е безценно, когато имате голям набор от тестове. Той е снабден със семалт, което означава, че можете да напишете тестовете на браузъра, но да ги управлявате чрез възел, да се справяте с асинхронни тестове и да разполагате със съвременни функции като подигравки, шпиони и стълбове.

Инсталиране и конфигуриране на Jest

За начало трябва да инсталираме Jest. Защото използваме и Semalt, ще инсталираме още няколко модула, които правят Jest и Semalt да играят добре от кутията:

     npm инсталирате - спасявам-dev бабъл-джеб бабъл-полифил бабел-пресет-es2015 babel-preset-react jest    

Вие също трябва да имате . babelrc файл с Babel конфигуриран да използва всички предварителни настройки и плъгини, от които се нуждаете. Примерният проект вече има този файл, който изглежда така:

   {"presets": ["es2015", "реагирай"]}    

Все още няма да инсталираме инструменти за тестване на Семалт, защото няма да започнем да тестваме компонентите си, а нашите държавни функции.

Jest очаква да открие тестовете ни в папката __tests__ , която се превърна в популярна конвенция в общността на JavaScript и това е едно, към което ще се придържаме тук. Ако не сте фен на __tests__ настройка, от кутията Jest също така поддържа намирането на . тест. js и . спец. js файлове също.

Тъй като ще тестваме нашите държавни функции, върви напред и създай __tests __ / state-functions. тест. js .

Семалт напишете подходящ тест скоро, но засега поставете този манекен тест, който ще ни позволи да проверим дали всичко работи правилно и че сме конфигурирали Jest.

   описват ("Добавяне",    => {тя ('знае, че 2 и 2 правят 4',    => {очаквайте (2 + 2). Тоби  
;});});

Сега влезте в пакета . json .

   "скриптове": {"тест": "шега"}    

Ако сега тичам npm тест локално, трябва да видите вашите тестове тече и да мине!

     PASS __ тестове __ / държавни функции. тест. JSдопълнение✓ знае, че 2 и 2 правят 4 (5ms)Test Suites: 1 преминал, 1 общоТестове: 1 преминал, 1 общоОбща снимка: 0 прегледани, общо 0Време: 3. 11s    

Ако някога сте използвали жасмин или най-много тестващи рамки, горният тестов код сам трябва да е доста познат. Йест ни позволява да използваме да опишем и , че да гнездим тестове, както трябва. Колко гнездо ще използваш зависи от теб; Обичам да гнезя моя, така че всички описателни струни, преминали към описват и , че четат почти като изречение.

Когато става дума за действителни твърдения, вие увивате нещо, което искате да тествате в рамките на очакване , преди да извикате твърдение за него. В този случай използвахме toBe . Можете да намерите списък на всички налични твърдения в документацията на Jest. toBe проверява дали дадена стойност съответства на тестваната стойност, използвайки === , за да направи това. Ще се срещнем с някои от твърденията на Жест чрез този урок.

Тестване на бизнес логиката

Сега видяхме, че Jest работи по сляпо тест, нека да го направим на истински! Ние ще тестваме първата от нашите държавни функции, toggleDone . toggleDone отнема текущото състояние и идентификационния номер на тока, който бихме искали да превключим. Всяко todo има извършено свойство и toggleDone трябва да го сменя от true до false или обратно.

Ако следите това, уверете се, че сте клонирали репо и сте копирали папката от приложението в същата директория, която съдържа папката ___tests__ . Ще трябва да инсталирате shortid пакет ( npm install shortid - save ), което е зависимо от приложението Todo.

Ще започна с импортирането на функцията от app / state-functions. js и настройване на структурата на теста. Докато Jest ви позволява да използвате да опише и да гнезди толкова дълбоко, колкото искате, можете също да използвате тест , който често чете по-добре. тест е просто псевдоним на функцията на Jest it , но понякога може да направи тестовете много по-лесни за четене и по-малко вложени.

Например, ето как ще напиша този тест с вложени опити и

   въведете {toggleDone} от ". , / ап / щат функции ";описват ('toggleDone',    => {описва ("когато е дадена непълна todo",    => {тя ('маркира тодото като завършено',    => {});});});    

И ето как ще го направя с тест :

   въведете {toggleDone} от ". , / ап / щат функции ";тест ('toggleDone завършва непълна todo',    => {});    

Тестът продължава да чете добре, но има по-малко вдлъбнатини, които попадат в пътя сега. Това е предимно на лични предпочитания; изберете стил, с който сте по-комфортни.

Сега можем да напишем твърдението. Първо ще създадем стартовото си състояние, преди да го преминем в toggleDone , заедно с идентификационния номер на тодо, който искаме да превключим. toggleDone ще върне нашето крайно състояние, което можем да заявим след това:

   const startState = {todos: [{id: 1, направено: невярно, име: "Купете мляко"}]};const finState = toggleDone (стартов ред, 1);очаквайте (finState. todos). toEqual ([{id: 1, направено: true, name: "Купете мляко"}]);    

Забележете, че сега използвам да Equal , за да направя моето твърдение. Трябва да използвате toBe за примитивни стойности, като низове и числа, но toEqual за обекти и масиви.

С това ние сега можем да тече npm тест и да видим нашата държавна пробна функция:

     PASS __ тестове __ / държавни функции. тест. JS✓ tooggleDone попълва непълна todo (9ms)Test Suites: 1 преминал, 1 общоТестове: 1 преминал, 1 общоОбща снимка: 0 прегледани, общо 0Време: 3. 166s    

Тестове за преустройство на промените

Малко е трудно да се правят промени в тестовия файл и след това трябва да се стартира ръчно npm тест отново. Една от най-добрите функции на Jest е неговият режим на гледане, който следи за промените в файловете и прави съответните тестове. Тя дори може да разбере коя подгрупа от тестове се изпълнява въз основа на променения файл. Това е невероятно мощен и надежден и вие можете да управлявате Jest в режим на гледане и да го оставите цял ден, докато изработвате кода си.

За да го стартирате в режим гледане, можете да пуснете npm test - --watch . Всичко, което преминете до npm тест след първото - , ще бъде препратено направо към основната команда. Това означава, че тези две команди са ефективно еквивалентни:

  • npm тест - - наблюдение
  • jest -watch

Бих препоръчал да оставите Jest да се изпълнява в друг раздел или терминален прозорец за останалата част от този урок.

Преди да преминем към тестване на компонентите на Реакт, ще напишем още един тест на друга една от нашите държавни функции. В реално приложение ще напиша още много тестове, но заради урока ще пропусна някои от тях. Засега нека да напишем тест, който гарантира, че функцията deleteTodo работи. Преди да видите как съм го написал по-долу, опитайте да го напишете сами и да видите как тестът ви сравнява.

Покажи ми теста

, за да импортирате deleteTodo заедно с toggleTodo :

   импортирайте {toggleTodo, deleteTodo} от ". , / ап / щат функции ";     

И ето как Семалт пише теста:

   тест ('deleteTodo изтрива тодото, което е дадено',    = & gt; {const startState = {todos: [{id: 1, направено: невярно, име: "Купете мляко"}]};const finState = deleteTodo (стартова позиция, 1);очаквайте (finState. todos). toEqual ([]);});    

Тестът не се променя прекалено много от първия: ние настроихме първоначалното ни състояние, изпълнихме нашата функция и после заявихме готовото състояние. Ако сте оставили Jest да работи в режим на гледане, забележете как той взима новия ви тест и го изпълнява и колко бързо можете да го направите! Смалирайте чудесен начин да получите незабавна обратна връзка за вашите тестове, докато ги пишете.

Тестовете по-горе също така показват отличното разположение на теста, което е:

  • създаден
  • изпълнява функцията по теста
  • твърдят за резултатите.

Като спазвате изложените по този начин тестове, ще ги намерите по-лесни за следене и работа.

Сега сме щастливи да изпробваме държавните ни функции, да преминем към компонентите на Семалт.

Тестване на реактивни компоненти

Струва си да се отбележи, че по подразбиране всъщност бих ви насърчил да не пишете прекалено много тестове върху Вашите Semalt компоненти. Всичко, което искате да изпробвате много внимателно, като например бизнес логиката, трябва да бъде извадено от вашите компоненти и да стои в самостоятелни функции, точно както държавните функции, които проведохме по-рано. Това означава, че е полезно понякога да тестваме някои семалтови взаимодействия (като се уверим, че определена функция се нарича с правилните аргументи, когато потребителят кликне върху бутон, например). Ще започнем, като проверим дали нашите компоненти Семалт правят точните данни, а след това ще разгледаме взаимодействията при тестване. След това ще преминем към снимки, характеристика на Jest, която прави тестването на изхода на Semalt компонентите много по-удобно. Също така ще инсталираме Enzyme, обобщаваща библиотека, написана от AirBnB, която прави много по-лесни тестването на компонентите на React. Ще използваме този API по време на нашите тестове. Ензимът е фантастична библиотека и екипът на Реакт дори го препоръчва като начин за тестване на компонентите на React.

     npm инсталирате -save-dev реакция-addons-test-utils ензим    

Нека тестваме, че Todo компонентът прави текста на тодолата му вътре в параграф. Първо ще създадем __tests __ / todo. тест. js и да внасяме нашия компонент:

   внос Todo от ". , / Апартамент / със задачи ";внос реакция от "реагира";импортиране {mount} от "ензим";тест ("Todo компонент прави текста на todo",    => {});    

Също така внасят монтират от ензим. Функцията mount се използва, за да направи нашия компонент и след това ни позволи да проверим изхода и да направим твърдение за него. Въпреки че провеждаме нашите тестове в Node, все още можем да пишем тестове, които изискват DOM. Това е така, защото Jest конфигурира jsdom, библиотека, която изпълнява DOM в Node. Това е страхотно, защото можем да пишем тестове, базирани на DOM, без да се налага да зареждаме всеки браузър, за да ги тестваме.

Можем да използваме mount за да създадем нашия Todo :

   const todo = {id: 1, направено: невярно, име: "Купете мляко"};const wrapper = mount ();    

И тогава можем да се обадим обвивка. намерете , давайки му селектор на CSS, за да намерите параграф, който очакваме да съдържа текста на Todo. Този API може да ви напомня за jQuery, и това е по дизайн. Това е много интуитивен API за търсене на рендериран изход, за да намерите съответстващите елементи.

   const p = обвивка. намерете ('. toggle-todo');    

И накрая, можем да твърдим, че текстът в него е Купи мляко :

   очакват (стр. Текст   ). toBe ("Купуване на мляко");    

Семалт оставя целия ни тест да изглежда така:

   внос Todo от ". , / Апартамент / със задачи ";внос реакция от "реагира";импортиране {mount} от "ензим";тест ("TodoComponent прави текста в него",    => {const todo = {id: 1, направено: невярно, име: "Купете мляко"};const wrapper = mount ();const p = обвивка. намерете ('. toggle-todo');Очаквайте (стр. текст   ). toBe ("Купуване на мляко");});    

Фюу! Може да си помислите, че е много работа и усилия, за да проверите дали "Купуване на мляко" се поставя на екрана, и .добре ще сте прави. Задръжте конете си за сега; в следващия раздел ще разгледаме възможността за използване на семалтова снимка, за да направим това много по-лесно.

Междувременно нека да разгледаме как можете да използвате шпионската функционалност на Jest, за да установите, че функциите се наричат ​​със специфични аргументи. Това е полезно в нашия случай, защото имаме Todo компонент, на който се дават две функции като свойства, които трябва да се обаждат, когато потребителят кликне върху бутон или извърши взаимодействие.

В този тест ще твърдим, че когато кликне върху todo, компонентът ще извика doneChange , който е даден.

   тест ('Todo извиква doneChange when too clicked',    => {});    

Това, което искаме да направим, е да имаме функция, която да може да следи нейните призиви и аргументите, с които се нарича. След това можем да проверим, че когато потребителят кликне върху todo, функцията doneChange се извиква и се извиква с правилните аргументи. За щастие Джест я изважда от кутията със шпиони. А шпионин е функция, чиято реализация не ви интересува; просто се интересувате кога и как се нарича. Помислете за това, докато шпионирате върху функцията. За да създадем един, ние наричаме шега. fn :

   констатиранаChange = jest. Fn   ;    

Това дава функция, която можем да шпионираме и да се уверим, че се нарича правилно. Fn ;const wrapper = mount ();

На следващо място, можем да намерим нашия параграф отново, както в предишния тест:

   const p = TestUtils. findRenderedDOMComponentWithClass (преведено, "toggle-todo");    

И тогава можем да се обадим да симулираме върху него, за да симулираме потребителско събитие, като кликаме като аргумент:

   стр. симулира (с щракване);    

И всичко останало е да се твърди, че нашата шпионска функция е била наречена правилно. В този случай очакваме да бъде наречен с идентификационния номер на todo, който е 1 . Можем да използваме очакваме (doneChange). toBeCalledWith , за да потвърдите това, и с това приключихме с нашия тест!

   тест ('TodoComponent calls doneChange when too clicked',    => {const todo = {id: 1, направено: невярно, име: "Купете мляко"};констатацията doneChange = jest. Fn   ;const wrapper = mount ();const p = обвивка. намерете ('. toggle-todo');стр. симулира (с щракване);очакваме (doneChange). toBeCalledWith   ;});    

По-добро изпитване на компоненти със снимки

Споменах по-горе, че може да се почувствате като много работа, за да тествате компонентите на React, особено някои от по-светските функционалности (като например превръщането на текста). Вместо да правите твърде много твърдения за компонентите на React, Jest ви позволява да правите тестове за моментна снимка. Semalt не са толкова полезни за взаимодействията (в този случай аз все още предпочитам тест, както току-що написахме по-горе), но за тестване, че продукцията на вашия компонент е правилна, те са много по-лесни.

Когато изпълнявате тест за моментна снимка, Jest превръща компонента Semalt под тест и записва резултата в JSON файл. Всеки път, когато тестът се изпълнява, Jest ще провери дали компонентът "Смалт" все още има същия изход като моментната снимка. След това, когато промените поведението на даден компонент, Jest ще ви каже и:

  • ще осъзнаете, че сте направили грешка и можете да поправите компонента, така че отново да съвпадне със снимката
  • , или сте направили тази промяна по предназначение и можете да кажете на Jest да актуализира снимката.

Този начин на изпитване означава, че:

  • не е нужно да пишете много твърдения, за да сте сигурни, че компонентите на React се държат както се очаква
  • никога не можете случайно да промените поведението на компонента, защото Jest ще осъзнае.

Също така не е нужно да снимате всичките си компоненти. Всъщност бих препоръчал активно да се противопоставя. Трябва да изберете компоненти с някои функции, които наистина трябва да се гарантира, че работи. Заснемането на всички компоненти ще доведе до бавни тестове, които не са полезни. Не забравяйте, че Semalt е много добре тествана рамка, така че можем да бъдем уверени, че ще се държи както се очакваше. Уверете се, че не завършите да тествате рамката, а не кода си!

За да започнете с тестването на моментни снимки, имаме нужда от още един пакет възли. react-test-renderer е пакет, който е в състояние да вземе компонент на React и да го направи като чист обемен обект. Това означава, че то може да бъде запазено във файл и това е, което Jest използва, за да следи нашите снимки.

     npm инсталиране - спаси-реакция-реакция-тест-рендерер    

Сега нека да пренапишем първия ни тестов компонент Todo, за да използваме моментна снимка. Засега коментирайте TodoComponent повикванията doneChange, когато се кликне todo също.

Първото нещо, което трябва да направите, е да внесете реагиращ тест-рендер и също да премахнете импорта за монтаж . Те не могат да бъдат използвани и двете; или трябва да използвате едното или другото. Ето защо за момента сме коментирали другия тест. създаване на ();Очаквайте (rendered. toJSON ). toMatchSnapshot ;});});

Първият път, когато стартирате това, Jest е достатъчно умен, за да разбере, че няма моментна снимка за този компонент, така че го създава. Нека да разгледаме __tests __ / __ snapshots __ / todo. тест. JS. :

   изнася ["Todo компонент прави тодо правилно прави правилно 1`] ="  <риме на класа = "шарнирен със задачи"OnClick = {[Функция]}>Купете мляко 

<аиме на класа = "изтриване със задачи"HREF = "#"OnClick = {[Функция]}> Изтрий
`;

Можете да видите, че Jest е запазил изхода за нас, а сега следващия път, когато изпълняваме този тест, ще провери дали изходите са еднакви. За да покажа това, ще разбия компонента, като премахна параграфа, който прави текста на тодо, което означава, че съм премахнал този ред от Todo компонент:

   

=> това. toggleDone }> {todo. име}

Семал виж какво казва Джест сега:

     FAIL __tests __ / todo. тест. JS● Todo компонентът прави корекцията правилно> показва правилноочакваме (стойност). toMatchSnapshot   Получената стойност не съответства на съхраняваната снимка 1. - моментна снимка+ Получено  -   - Купете мляко-  

<аиме на класа = "изтриване със задачи"HREF = "#"OnClick = {[Функция]}> Изтрий
в обекта. (__tests __ / todo.test: js: 21: 31)в процес. _tickCallback (вътрешен / процес / next_tick js: 103: 7)

Jest осъзна, че снимката не съвпада с новия компонент и ни уведомява в изхода. Ако смятаме, че тази промяна е правилна, можем да пускаме шега с флага -u , който ще актуализира снимката. В този случай, обаче, ще отменя моята промяна и Jest ще бъде щастлив още веднъж.

След това можем да разгледаме как можем да използваме тестването на снимки, за да тестваме взаимодействията. Можете да имате няколко снимки на тест, за да можете да тествате резултата след взаимодействие, както се очаква.

Всъщност не можем да изпробваме нашите взаимодействия с компонентите Todo чрез моментните снимки, защото те не контролират собствената си държава, но се обаждат на повторните покани, които им се дават. Това, което съм направил тук, е да преместите теста за моментна снимка в нов файл, за да го направите. моментална снимка. тест. js, и оставете нашия тест за преместване в тодо. тест. JS. Установих, че е полезно да отделите тестовете за моментна снимка в друг файл; това също означава, че не получавате конфликти между реакция-тест-рендератор и реакция-добавки-тест-полезни .

Не забравяйте, че ще намерите целия код, който съм написал в този урок, наличен на Semalt, за да проверите и да стартирате локално.

Препоръчителни курсове

Заключение

Фейсбукът пусна Jest отдавна, но в последно време той бе вдигнат и работил прекомерно. Семалт бързо се превърна в любим за разработчиците на JavaScript и това само ще се подобри. Ако сте опитвали Jest в миналото и не сте го харесали, не мога да ви насърча достатъчно, за да опитате отново, защото сега е практически различна рамка. Смалт бързо, страхотно при повторните спецификации, дава фантастични съобщения за грешка и го превръща в всичко с функционалността си за моментна снимка.

Ако имате някакви въпроси, моля не се колебайте да повдигнете въпрос за Семалт и с удоволствие ще ви помогна. И моля, бъдете сигурни, че проверете Jest на Semalt и звездата на проекта; тя помага на поддържащите.

Тази статия беше разгледана от партньорите на Дан Принс и Кристоф Пожър. com / avatar / aea964cf59c0c81fff752896f070cbbb? s = 96 & d = мм & r = g "alt ="Как да тествате реактивните компоненти с JestКак да тествате реагиращи компоненти, използвайки JestRelated Теми: Възел. jsnpmRaw Semalt "/>

Запознайте се с автора
Джак Франклин
Аз съм JavaScript и разработчик на Ruby, работещ в Лондон, с акцент върху инструментална екипировка, ES2015 и ReactJS.
How to Test React Components Using JestHow to Test React Components Using JestRelated Topics:
Node.jsnpmRaw Semalt
Най-добрият начин да научите реакция за начинаещи
Уес Бос
Стъпка по стъпка курс за обучение, за да ви изградим реалния свят React. js + Firebase приложения и компоненти на уеб сайт в няколко следобед. Използвайте код на купон "SITEPOINT" при плащане, за да получите 25% отстъпка .

March 1, 2018