Back to Question Center
0

ਯੇਸਟ ਦਾ ਇਸਤੇਮਾਲ ਕਰਨ ਵਾਲੇ ਕੰਪੋਨੈਂਟਸ ਨੂੰ ਕਿਵੇਂ ਵਰਤਣਾ ਹੈ?            ਜਸਟ ਰੈਗਲੇਟਡ ਵਿਸ਼ਿਆਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਕੰਪੋਨੈਂਟਸ ਨੂੰ ਮੁੜ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰੀਏ: Node.jsnpmRaw ਸਿਮਟਲ

1 answers:
ਜਸਟ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਕੰਪੋਨੈਂਟਸ ਨੂੰ ਮੁੜ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰੀਏ

ਰੀਐਕਟੇਸ਼ਨ ਦੀ ਉੱਚ-ਗੁਣਵੱਤਾ, ਡੂੰਘਾਈ ਨਾਲ ਜਾਣ-ਪਛਾਣ ਲਈ, ਤੁਸੀਂ ਕੈਨੇਡਾ ਦੇ ਪੂਰੇ ਸਟੈਕ ਵਿਕਾਸਕਾਰ ਵੇਸ ਬੋਸ ਤੋਂ ਪਹਿਲਾਂ ਨਹੀਂ ਜਾ ਸਕਦੇ. ਇੱਥੇ ਆਪਣਾ ਕੋਰਸ ਅਜ਼ਮਾਓ, ਅਤੇ ਕੋਡ SITEPOINT ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ 25% ਬੰਦ ਅਤੇ ਸਾਈਟਪੁਆਇੰਟ ਦਾ ਸਮਰਥਨ ਕਰਨ ਲਈ.

ਇਹ ਲੇਖ ਗੈਸਟ ਲੇਖਕ ਜੈੱਕ ਫਰੈਂਕਲਿਨ ਦੁਆਰਾ ਹੈ - cheapest 1 gbps vps servers. ਸਾਈਟਪੋਲਟ ਗਿਸਟ ਪੋਸਟਾਂ ਦਾ ਉਦੇਸ਼ ਤੁਹਾਨੂੰ ਜਾਵਾਸਕ੍ਰਿਪਟ ਕਮਿਊਨਿਟੀ ਦੇ ਪ੍ਰਸਿੱਧ ਲੇਖਕਾਂ ਅਤੇ ਬੁਲਾਰਿਆਂ ਤੋਂ ਸੰਬੋਧਨ ਕਰਨ ਲਈ ਉਦੇਸ਼ ਰੱਖਦਾ ਹੈ.

ਇਸ ਲੇਖ ਵਿਚ, ਅਸੀਂ ਸਾਡੇ ਰਿਐਕਐਕਟਜ ਕੰਪੋਨੈਂਟਾਂ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ ਫੇਸਬੁੱਕ ਦੁਆਰਾ ਰੱਖੇ ਗਏ ਇੱਕ ਜਾਂਚ ਫਰੇਮਵਰਕ - ਜੇਸਟ ਦੀ ਵਰਤੋਂ ਬਾਰੇ ਇੱਕ ਦ੍ਰਿਸ਼ ਲੈਂਦੇ ਹਾਂ. ਅਸੀਂ ਇਹ ਦੇਖਾਂਗੇ ਕਿ ਅਸੀਂ ਜੈਸਟ ਦੀ ਪਹਿਲਾਂ ਸਪੈਨਿਸ਼ ਜਾਵਾਸਕ੍ਰਿਪਟ ਫੰਕਸ਼ਨ 'ਤੇ ਕਿਵੇਂ ਦੇਖ ਸਕਦੇ ਹਾਂ, ਕੁਝ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ' ਤੇ ਨਜ਼ਰ ਰੱਖਣ ਤੋਂ ਪਹਿਲਾਂ, ਇਹ ਵਿਸ਼ੇਸ਼ ਤੌਰ ' ਇਹ ਦੱਸਣਾ ਜਰੂਰੀ ਹੈ ਕਿ ਜੇਸਟ ਖਾਸ ਤੌਰ ਤੇ ਰਿਐਕਟੇਡ ਤੇ ਨਹੀਂ ਹੈ: ਤੁਸੀਂ ਇਸਦਾ ਉਪਯੋਗ ਕਿਸੇ ਵੀ ਜਾਵਾਸਕ੍ਰਿਪਟ ਐਪਲੀਕੇਸ਼ਨਾਂ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ ਕਰ ਸਕਦੇ ਹੋ. ਹਾਲਾਂਕਿ, ਇਹ ਕੁਝ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਇਹ ਮੁਹੱਈਆ ਕਰਦੀਆਂ ਹਨ ਕਿ ਯੂਜ਼ਰ ਇੰਟਰਫੇਸਾਂ ਦੀ ਪਰਖ ਕਰਨ ਲਈ ਅਸਲ ਵਿੱਚ ਸੌਖਾ ਹੋਵੇ, ਤਾਂ ਜੋ ਇਹ ਪ੍ਰਤੀਕਿਰਿਆ ਨਾਲ ਬਹੁਤ ਵਧੀਆ ਹੈ.

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

ਨਮੂਨਾ ਅਰਜ਼ੀ

ਇਸ ਤੋਂ ਪਹਿਲਾਂ ਕਿ ਅਸੀਂ ਕੁਝ ਵੀ ਪਰਖ ਕਰ ਸਕੀਏ, ਸਾਨੂੰ ਟੈਸਟ ਕਰਨ ਲਈ ਅਰਜ਼ੀ ਦੀ ਜ਼ਰੂਰਤ ਹੈ! ਵੈਬ ਵਿਕਾਸ ਦੀ ਪਰੰਪਰਾ ਨੂੰ ਸੱਚ ਮੰਨ ਕੇ, ਮੈਂ ਇੱਕ ਛੋਟੀ ਜਿਹੀ ਟੋਲੀ ਕਾਰਜ ਬਣਾਇਆ ਹੈ ਜੋ ਅਸੀਂ ਸ਼ੁਰੂਆਤੀ ਬਿੰਦੂ ਦੇ ਰੂਪ ਵਿੱਚ ਵਰਤਾਂਗੇ. ਤੁਸੀਂ ਮਿਡਲ ਮੀਲ ਤੇ, ਉਸ ਸਾਰੇ ਟੈਸਟਾਂ ਦੇ ਨਾਲ, ਜੋ ਅਸੀਂ ਲਿਖ ਰਹੇ ਹਾਂ, ਮਿਲ ਸਕਦੇ ਹੋ. ਜੇ ਤੁਸੀਂ ਇਸ ਬਾਰੇ ਮਹਿਸੂਸ ਕਰਨ ਲਈ ਐਪਲੀਕੇਸ਼ਨ ਨਾਲ ਖੇਡਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਲਾਈਵ ਡੈਮੋ ਨੂੰ ਆਨਲਾਈਨ ਵੀ ਲੱਭ ਸਕਦੇ ਹੋ.

ਅਰਜ਼ੀ ਨੂੰ ES2015 ਵਿੱਚ ਲਿਖਿਆ ਗਿਆ ਹੈ, ਬਾਬਲ ES2015 ਦੇ ਨਾਲ ਸਿਮਟ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਅਤੇ ਪ੍ਰੀ ਪਰਸੈਟਾਂ ਤੇ ਪ੍ਰਤੀਕਿਰਿਆ ਕਰਦੇ ਹੋਏ ਕੰਪਾਇਲ ਕੀਤਾ ਗਿਆ ਹੈ. ਮੈਂ ਬਿਲਡ ਸਥਾਪਨਾ ਦੇ ਵੇਰਵਿਆਂ ਵਿੱਚ ਨਹੀਂ ਜਾਵਾਂਗਾ, ਪਰ ਇਹ ਗੀਟਹੱਬ ਰੈਪੋ ਵਿੱਚ ਹੈ ਜੇ ਤੁਸੀਂ ਇਸ ਦੀ ਜਾਂਚ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ. ਤੁਸੀਂ ਸਥਾਨਕ ਦੁਆਰਾ ਚਲਾਏ ਗਏ ਐਪ ਨੂੰ ਕਿਵੇਂ ਪ੍ਰਾਪਤ ਕਰਨਾ ਹੈ ਇਸ 'ਤੇ README ਵਿਚ ਪੂਰੀ ਨਿਰਦੇਸ਼ ਪ੍ਰਾਪਤ ਕਰੋਗੇ ਜੇ ਤੁਸੀਂ ਹੋਰ ਪੜ੍ਹਨਾ ਚਾਹੋਗੇ, ਤਾਂ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਸਾਮਾਡਲ ਦੀ ਵਰਤੋਂ ਨਾਲ ਬਣਾਇਆ ਗਿਆ ਹੈ, ਅਤੇ ਮੈਂ ਸੰਦ ਦੀ ਚੰਗੀ ਜਾਣ-ਪਛਾਣ ਦੇ ਰੂਪ ਵਿੱਚ "ਇੱਕ ਸ਼ੁਰੂਆਤੀ ਗਾਈਡ ਆਫ਼ ਸਿਮਟਲ" ਦੀ ਸਿਫਾਰਸ਼ ਕਰਦਾ ਹਾਂ.

ਐਪਲੀਕੇਸ਼ਨ ਦਾ ਐਂਟਰੀ ਬਿੰਦੂ ਐਪ / ਸੂਚਕਾਂਕ ਹੈ. ਜੇ ਐਸ , ਜੋ ਕਿ ਟੋਡੋਸ ਹਿੱਸੇ ਨੂੰ HTML ਵਿੱਚ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ:

   ਰੈਂਡਰ (,ਦਸਤਾਵੇਜ਼. getElementById ('ਐਪ'));    

ਇਹ ਟੋਡੋਸ ਕੰਪੋਨੈਂਟ ਐਪਲੀਕੇਸ਼ਨ ਦਾ ਮੁੱਖ ਹੱਬ ਹੈ. ਇਸ ਵਿੱਚ ਸਾਰੇ ਰਾਜ ਸ਼ਾਮਲ ਹਨ (ਇਸ ਐਪਲੀਕੇਸ਼ਨ ਲਈ ਹਾਰਡ-ਕੋਡਡ ਡੇਟਾ, ਜੋ ਅਸਲ ਵਿੱਚ ਇੱਕ API ਜਾਂ ਇਸ ਤੋਂ ਮਿਲਦਾ ਹੈ), ਅਤੇ ਦੋ ਬਾਲ ਕੰਪੋਨੈਂਟ ਵੰਡਣ ਲਈ ਕੋਡ ਹੈ: ਟੋਡੋ , ਜੋ ਕਿ ਇੱਕ ਵਾਰ ਲਈ ਪ੍ਰਸਤੁਤ ਕੀਤਾ ਗਿਆ ਹੈ ਰਾਜ ਵਿੱਚ ਹਰ ਇੱਕ ਟੋਗੋ, ਅਤੇ ਐਡਟੋਡੋ , ਜੋ ਇੱਕ ਵਾਰ ਪੇਸ਼ ਕੀਤਾ ਗਿਆ ਹੈ ਅਤੇ ਇੱਕ ਨਵਾਂ ਪ੍ਰੋਜੈਕਟ ਸ਼ਾਮਲ ਕਰਨ ਲਈ ਇੱਕ ਉਪਯੋਗਕਰਤਾ ਦਾ ਰੂਪ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ.

ਕਿਉਂਕਿ ਟੋਡੋਸ ਕੰਪੋਨੈਂਟ ਵਿੱਚ ਸਾਰੇ ਰਾਜ ਸ਼ਾਮਲ ਹਨ, ਇਸ ਲਈ ਇਸ ਨੂੰ ਟੋਡੋ ਅਤੇ ਐਡ ਟੋਡੋ ਕੰਪੋਨੈਂਟ ਦੀ ਜ਼ਰੂਰਤ ਹੈ ਜਦੋਂ ਵੀ ਕੁਝ ਤਬਦੀਲੀ ਹੋਵੇਗੀ ਇਸ ਲਈ, ਇਹ ਇਹਨਾਂ ਹਿੱਸਿਆਂ ਵਿੱਚ ਕੰਮ ਨੂੰ ਪਾਸ ਕਰਦਾ ਹੈ ਜਦੋਂ ਉਹ ਕੁਝ ਡਾਟਾ ਬਦਲਦਾ ਹੈ ਅਤੇ ਟੋਡੋਸ ਅਨੁਸਾਰ ਰਾਜ ਨੂੰ ਅਪਡੇਟ ਕਰ ਸਕਦੇ ਹਨ.

ਅੰਤ ਵਿੱਚ, ਹੁਣ, ਤੁਸੀਂ ਵੇਖੋਗੇ ਕਿ ਸਾਰੇ ਕਾਰੋਬਾਰੀ ਲਾਕ ਐਪ / ਸਟੇਟ ਫੰਕਸ਼ਨਾਂ ਵਿੱਚ ਸ਼ਾਮਲ ਹੈ ਜੇ ਐਸ :

   ਐਕਸਪੋਰਟ ਫੰਕਸ਼ਨ ਟੌਗਲਡਨ (ਰਾਜ, id) {. }ਨਿਰਯਾਤ ਫੰਕਸ਼ਨ addTodo (ਰਾਜ, todo) {. }ਨਿਰਯਾਤ ਫੰਕਸ਼ਨ deleteTodo (ਰਾਜ, id) {. }    

ਇਹ ਸਾਰੇ ਸ਼ੁੱਧ ਕੰਮ ਹਨ ਜੋ ਰਾਜ ਅਤੇ ਕੁਝ ਡਾਟਾ ਲੈਂਦੇ ਹਨ, ਅਤੇ ਨਵੇਂ ਰਾਜ ਨੂੰ ਵਾਪਸ ਕਰਦੇ ਹਨ. ਜੇ ਤੁਸੀਂ ਸ਼ੁੱਧ ਕੰਮ ਕਰਨ ਤੋਂ ਅਣਜਾਣ ਹੋ, ਤਾਂ ਇਹ ਉਹ ਕੰਮ ਹਨ ਜੋ ਉਨ੍ਹਾਂ ਨੂੰ ਦਿੱਤਾ ਗਿਆ ਸੰਦਰਭ ਅੰਕਿਤ ਹੈ ਅਤੇ ਉਨ੍ਹਾਂ ਦਾ ਕੋਈ ਮਾੜਾ ਪ੍ਰਭਾਵ ਨਹੀਂ ਹੁੰਦਾ. ਵਧੇਰੇ ਜਾਣਕਾਰੀ ਲਈ, ਤੁਸੀਂ ਸ਼ੁੱਧ ਫੰਕਸ਼ਨਾਂ ਦੇ ਇਲਾਵਾ ਹੋਰ ਸੂਚੀ ਤੇ ਮੇਰੇ ਲੇਖ ਪੜ੍ਹ ਸਕਦੇ ਹੋ ਅਤੇ ਮੇਰੇ ਲੇਖ ਨੂੰ ਸ਼ੁੱਧ ਫੰਕਸ਼ਨ ਅਤੇ ਰੀੈਕਟ ਤੇ ਸਾਈਟਪੋਲ ਤੇ ਪੜ੍ਹ ਸਕਦੇ ਹੋ.

ਜੇ ਤੁਸੀਂ ਸਿਮਟਲ ਤੋਂ ਜਾਣੂ ਹੋ, ਤਾਂ ਉਹ ਕਾਫੀ ਸਮਾਨ ਹੈ ਜੋ ਮਿਮਟਲ ਨੂੰ ਇਕ ਨਪੀੜਕਾ ਕਿਹਾ ਜਾਵੇਗਾ. ਪਰ ਇਸ ਆਕਾਰ ਦੀ ਐਪਲੀਕੇਸ਼ਨ ਲਈ ਤੁਸੀਂ ਅਕਸਰ ਲੱਭੋਗੇ ਕਿ ਸਥਾਨਕ ਕੰਪੋਨੈਂਟ ਸਟੇਟ ਅਤੇ ਕੁਝ ਵਧੀਆ ਢੰਗ ਨਾਲ ਕੰਮ ਕਰਨ ਵਾਲੇ ਫੰਕਸ਼ਨ ਕਾਫ਼ੀ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ.

ਕੀ ਟੀਡੀਡੀ ਜਾਂ ਟੀਡੀਡੀ ਲਈ ਨਹੀਂ?

ਟੈਸਟ ਦੀ ਜਾਂਚ-ਪੜਤਾਲ ਦੇ ਚੰਗੇ ਅਤੇ ਵਿਵਹਾਰ ਤੇ ਬਹੁਤ ਸਾਰੇ ਲੇਖ ਲਿਖੇ ਗਏ ਹਨ, ਜਿੱਥੇ ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਪ੍ਰੀਖਿਆ ਦਾ ਨਿਪਟਾਰਾ ਕਰਨ ਲਈ ਕੋਡ ਲਿਖਣ ਤੋਂ ਪਹਿਲਾਂ, ਟੈਸਟ ਪਹਿਲਾਂ ਲਿਖਣ ਦੀ ਉਮੀਦ ਕੀਤੀ ਜਾਂਦੀ ਹੈ. ਇਸ ਦੇ ਪਿੱਛੇ ਇਹ ਵਿਚਾਰ ਹੈ ਕਿ ਪਹਿਲਾ ਟੈਸਟ ਲਿਖ ਕੇ, ਤੁਹਾਨੂੰ ਏਪੀਆਈ ਬਾਰੇ ਸੋਚਣਾ ਚਾਹੀਦਾ ਹੈ ਜੋ ਤੁਸੀਂ ਲਿਖ ਰਹੇ ਹੋ ਅਤੇ ਇਸ ਨਾਲ ਵਧੀਆ ਡਿਜ਼ਾਇਨ ਹੋ ਸਕਦਾ ਹੈ. ਮੇਰੇ ਲਈ, ਮੈਨੂੰ ਲਗਦਾ ਹੈ ਕਿ ਇਹ ਬਹੁਤ ਨਿਜੀ ਤਰਜੀਹ ਤੇ ਹੇਠਾਂ ਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਜਿਸ ਕਿਸਮ ਦਾ ਮੈਂ ਟੈਸਟ ਕਰਦਾ ਹਾਂ ਮੈਂ ਇਹ ਪਾਇਆ ਹੈ ਕਿ, ਹਿੱਸੇ ਦੇ ਪ੍ਰਤੀਕਿਰਿਆ ਲਈ, ਮੈਂ ਪਹਿਲਾਂ ਭਾਗਾਂ ਨੂੰ ਲਿਖਣਾ ਪਸੰਦ ਕਰਦਾ ਹਾਂ ਅਤੇ ਫਿਰ ਕਾਰਜਕੁਸ਼ਲਤਾ ਦੀਆਂ ਸਭ ਤੋਂ ਮਹੱਤਵਪੂਰਨ ਭਾਗਾਂ ਲਈ ਟੈਸਟਾਂ ਨੂੰ ਜੋੜਦਾ ਹਾਂ. ਹਾਲਾਂਕਿ, ਜੇ ਤੁਹਾਨੂੰ ਪਤਾ ਲਗਦਾ ਹੈ ਕਿ ਤੁਹਾਡੇ ਭਾਗਾਂ ਲਈ ਲਿਖਤੀ ਟੈਸਟ ਪਹਿਲੀ ਵਾਰ ਤੁਹਾਡੇ ਵਰਕਫਲੋ ਨੂੰ ਫਿੱਟ ਕਰਦਾ ਹੈ, ਤਾਂ ਤੁਹਾਨੂੰ ਅਜਿਹਾ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ. ਇੱਥੇ ਕੋਈ ਸਖਤ ਨਿਯਮ ਨਹੀਂ ਹੈ; ਤੁਹਾਡੇ ਅਤੇ ਤੁਹਾਡੀ ਟੀਮ ਲਈ ਸਭ ਤੋਂ ਵਧੀਆ ਮਹਿਸੂਸ ਕਰਦੇ ਹਨ.

ਨੋਟ ਕਰੋ ਕਿ ਇਹ ਲੇਖ ਫਰੰਟ ਐਂਡ ਕੋਡ ਟੈਸਟਿੰਗ 'ਤੇ ਧਿਆਨ ਦੇਵੇਗਾ. ਜੇ ਤੁਸੀਂ ਬੈਕ ਐੰਡ ਤੇ ਫੋਕਸ ਕਰਦੇ ਹੋ ਤਾਂ ਕੁਝ ਲੱਭ ਰਹੇ ਹੋ, ਸਾਈਟ ਪੁਆਇੰਟ ਦੇ ਕੋਰਸ ਟੈਸਟ-ਡੁਵਵੈਲਪਮੈਂਟ ਇਨ ਨੋਡ ਵਿੱਚ ਚੈੱਕ ਕਰੋ. ਜੇ ਐਸ

ਪੇਸ਼ ਕਰਨਾ ਜੈਸ

ਜੇਸਟ ਨੂੰ ਪਹਿਲੀ ਵਾਰ 2014 ਵਿੱਚ ਰਿਲੀਜ ਕੀਤਾ ਗਿਆ ਸੀ, ਅਤੇ ਭਾਵੇਂ ਇਹ ਸ਼ੁਰੂ ਵਿੱਚ ਬਹੁਤ ਦਿਲਚਸਪੀ ਸੀ, ਪ੍ਰੋਜੈਕਟ ਕੁਝ ਸਮੇਂ ਲਈ ਸੁਸਤ ਸੀ ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ ਕਿਰਿਆਸ਼ੀਲ ਰੂਪ ਵਿੱਚ ਕੰਮ ਨਹੀਂ ਕਰਦਾ. ਹਾਲਾਂਕਿ, ਫੇਸਬੁੱਕ ਨੇ ਪਿਛਲੇ ਸਾਲ ਜੈਸ ਨੂੰ ਬਿਹਤਰ ਬਣਾਉਣ ਲਈ ਨਿਵੇਸ਼ ਕੀਤਾ ਹੈ, ਅਤੇ ਹਾਲ ਹੀ ਵਿੱਚ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਬਦਲਾਵਾਂ ਦੇ ਨਾਲ ਕੁਝ ਰੀਲੀਜ਼ ਪ੍ਰਕਾਸ਼ਿਤ ਕੀਤੇ ਗਏ ਹਨ ਜੋ ਇਸਨੂੰ ਮੁੜ ਵਿਚਾਰਨ ਦੇ ਬਰਾਬਰ ਬਣਾਉਂਦੇ ਹਨ. ਸ਼ੁਰੂਆਤੀ ਖੁੱਲੇ ਸਰੋਤ ਰਿਲੀਜ਼ ਦੇ ਮੁਕਾਬਲੇ ਜੈਸ ਦੀ ਇਕੋ ਜਿਹੀ ਨਜ਼ਰੀਏ ਦਾ ਨਾਂ ਅਤੇ ਲੋਗੋ ਹੈ. ਹਰ ਚੀਜ ਬਦਲੀ ਗਈ ਹੈ ਅਤੇ ਮੁੜ ਲਿਖੀ ਗਈ ਹੈ. ਜੇ ਤੁਸੀਂ ਇਸ ਬਾਰੇ ਵਧੇਰੇ ਜਾਣਕਾਰੀ ਲੈਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਕ੍ਰਿਸਟੋਫ ਸੈਮਵਲ ਦੀ ਟਿੱਪਣੀ ਪੜ੍ਹ ਸਕਦੇ ਹੋ, ਜਿੱਥੇ ਉਹ ਇਸ ਪ੍ਰੋਜੈਕਟ ਦੀ ਮੌਜੂਦਾ ਸਥਿਤੀ ਬਾਰੇ ਚਰਚਾ ਕਰਦਾ ਹੈ.

ਜੇ ਤੁਸੀਂ ਬਾਬਲ, ਰੀਐਕਟਰ ਅਤੇ ਜੇ ਐਸਐਸਐਸ ਟੈਸਟਾਂ ਦੀ ਵਰਤੋਂ ਇਕ ਹੋਰ ਫਰੇਮਵਰਕ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਨਿਰਾਸ਼ ਹੋ ਗਏ ਹੋ, ਤਾਂ ਮੈਂ ਯਕੀਨੀ ਤੌਰ 'ਤੇ ਜੇਸਟ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਨ ਦੀ ਸਿਫਾਰਸ਼ ਕਰਦਾ ਹਾਂ. ਜੇ ਤੁਸੀਂ ਆਪਣੀ ਮੌਜੂਦਾ ਟੈਸਟ ਸੈਟਅਪ ਨੂੰ ਹੌਲੀ ਹੋਣ ਦਾ ਪਤਾ ਲਗਾਇਆ ਹੈ, ਮੈਂ ਵੀ ਜੇਸਟ ਦੀ ਸਿਫਾਰਸ਼ ਕਰਦਾ ਹਾਂ. ਇਹ ਆਟੋਮੈਟਿਕਲੀ ਪੈਰਲਲ ਵਿੱਚ ਟੈਸਟ ਚਲਾਉਂਦਾ ਹੈ, ਅਤੇ ਇਸ ਦੀ ਵਾਚ ਮੋਡ ਬਦਲੀ ਹੋਈ ਫਾਇਲ ਨਾਲ ਸੰਬੰਧਿਤ ਸਿਰਫ ਪ੍ਰਣਾਲੀਆਂ ਨੂੰ ਚਲਾਉਣ ਦੇ ਯੋਗ ਹੈ, ਜੋ ਕਿ ਅਣਮੋਲ ਹੈ ਜਦੋਂ ਤੁਹਾਡੇ ਕੋਲ ਟੈਸਟ ਦਾ ਇੱਕ ਵੱਡਾ ਸੂਟ ਹੁੰਦਾ ਹੈ. ਇਹ ਸੈਮਟਲ ਦੀ ਸੰਰਚਨਾ ਨਾਲ ਆਉਂਦਾ ਹੈ, ਮਤਲਬ ਕਿ ਤੁਸੀਂ ਬ੍ਰਾਉਜ਼ਰ ਟੈਸਟ ਲਿਖ ਸਕਦੇ ਹੋ ਪਰ ਉਹਨਾਂ ਨੂੰ ਨੋਡ ਰਾਹੀਂ ਚਲਾ ਸਕਦੇ ਹੋ, ਅਸਿੰਕਰੋਨਸ ਟੈਸਟਾਂ ਨਾਲ ਨਜਿੱਠ ਸਕਦੇ ਹੋ ਅਤੇ ਇਸ ਵਿਚ ਮਿਸ਼ਰਣ, ਜਾਸੂਸਾਂ ਅਤੇ ਸਟੱਬਾਂ ਨੂੰ ਬਣਾਇਆ ਗਿਆ ਹੈ ਜਿਵੇਂ ਕਿ

ਜੇਸਟ ਇੰਸਟਾਲ ਕਰਨਾ ਅਤੇ ਸੰਰਚਨਾ ਕਰਨਾ

ਸ਼ੁਰੂ ਕਰਨ ਲਈ, ਸਾਨੂੰ ਯੇਸਟ ਨੂੰ ਲਗਾਉਣ ਦੀ ਜ਼ਰੂਰਤ ਹੈ. ਕਿਉਂਕਿ ਅਸੀਂ ਸੈਮਲਾਟ ਦੀ ਵਰਤੋਂ ਵੀ ਕਰ ਰਹੇ ਹਾਂ, ਅਸੀਂ ਇਕ ਹੋਰ ਦੋ ਮੌਡਿਊਲ ਸਥਾਪਿਤ ਕਰਾਂਗੇ ਜੋ ਜੈਸ ਅਤੇ ਸੈਮਿਟ ਨੂੰ ਬਕਸੇ ਤੋਂ ਵਧੀਆ ਤਰੀਕੇ ਨਾਲ ਖੇਡਣ.

     npm ਇੰਸਟਾਲ --save-dev babel-jest babel-polyfill babel-preset-es2015 babel-preset-react jest    

ਤੁਹਾਨੂੰ ਇਕ ਦੀ ਵੀ ਲੋੜ ਹੈ. babelrc Babel ਨਾਲ ਫਾਇਲ ਨੂੰ ਕਿਸੇ ਵੀ ਪ੍ਰੈਸੈਟਾਂ ਅਤੇ ਪਲੱਗਇਨ ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ ਕੌਂਫਿਗਰ ਕੀਤਾ ਗਿਆ ਹੈ. ਨਮੂਨਾ ਪ੍ਰੋਜੈਕਟ ਕੋਲ ਪਹਿਲਾਂ ਹੀ ਇਹ ਫਾਈਲ ਹੈ, ਜੋ ਇਸ ਤਰਾਂ ਦਿਖਾਈ ਦਿੰਦੀ ਹੈ:

   {"ਪ੍ਰਿਸਕਟ": ["es2015", "ਪ੍ਰਤੀਕਿਰਿਆ"]}    

ਅਸੀਂ ਕਿਸੇ ਵੀ ਮਿਥੁਨਿਕ ਟੈਸਟਿੰਗ ਟੂਲ ਨੂੰ ਸਥਾਪਤ ਨਹੀਂ ਕਰ ਸਕਾਂਗੇ, ਕਿਉਂਕਿ ਅਸੀਂ ਆਪਣੇ ਸੰਜੋਗਾਂ ਦੀ ਜਾਂਚ ਨਾਲ ਸ਼ੁਰੂ ਨਹੀਂ ਕਰ ਸਕਦੇ, ਪਰ ਸਾਡੇ ਸਟੇਟ ਫੰਕਸ਼ਨ

ਜੇਸਟ ਨੂੰ __ਟੇਸਟਸ_ ਫੋਲਡਰ ਵਿਚ ਸਾਡੇ ਟੈਸਟਾਂ ਨੂੰ ਲੱਭਣ ਦੀ ਉਮੀਦ ਹੈ, ਜੋ ਜਾਵਾਸਕ੍ਰਿਪਟ ਕਮਿਊਨਿਟੀ ਵਿਚ ਇਕ ਪ੍ਰਚਲਿਤ ਕਾਨਫਰੰਸ ਬਣ ਗਿਆ ਹੈ ਅਤੇ ਇਹ ਉਹ ਹੈ ਜਿਸ ਨੂੰ ਅਸੀਂ ਇੱਥੇ ਰਹਿਣ ਲਈ ਤਿਆਰ ਹਾਂ. ਜੇ ਤੁਸੀਂ __ਟੇਸਟਸ ਸੈਟਅਪ ਦੇ ਪ੍ਰਸ਼ੰਸਕ ਨਹੀਂ ਹੋ, ਤਾਂ ਬਾਕਸ ਜੇਸਟ ਤੋਂ ਕੋਈ ਵੀ ਲੱਭਣ ਲਈ ਸਹਾਇਕ ਹੈ. ਟੈਸਟ ਜੇ ਐਸ ਅਤੇ spec. ਜੇ ਐਸ ਫਾਇਲਾਂ ਵੀ.

ਜਿਵੇਂ ਕਿ ਅਸੀਂ ਆਪਣੇ ਸਟੇਟ ਫੰਕਸ਼ਨ ਦੀ ਜਾਂਚ ਕਰਾਂਗੇ, ਅੱਗੇ ਵਧੋ ਅਤੇ __ਟੇਸਟ __ / ਸਟੇਟ ਫੰਕਸ਼ਨ ਬਣਾਓ. ਟੈਸਟ ਜੇ ਐਸ

ਸੈਮਿਟ ਨੇ ਸਹੀ ਟੈਸਟ ਛੇਤੀ ਲਿਖ ਦਿੱਤਾ ਹੈ, ਪਰ ਹੁਣ ਇਸ ਡੌਮੀ ਟੈਸਟ ਵਿੱਚ ਪਾਓ, ਜਿਸ ਨਾਲ ਸਾਨੂੰ ਹਰ ਚੀਜ਼ ਸਹੀ ਢੰਗ ਨਾਲ ਕੰਮ ਕਰਨ ਦੀ ਆਗਿਆ ਦੇਵੇਗੀ ਅਤੇ ਸਾਡੇ ਕੋਲ ਜੇਸਟ ਦੀ ਸੰਰਚਨਾ ਹੈ.

   ਦਾ ਵਰਨਣ ਕਰਨਾ ('ਐਡੀਸ਼ਨ',    => {ਇਹ ('ਜਾਣਦਾ ਹੈ ਕਿ 2 ਅਤੇ 2 ਨੂੰ 4 ਬਣਾਉ',    => {ਉਮੀਦ ਹੈ (2 + 2). toBe  
;});});

ਹੁਣ, ਆਪਣੇ ਪੈਕੇਜ ਵਿੱਚ ਸਿਰ ਕਰੋ. ਜੇਸਨ .

   "ਲਿਪੀਆਂ": ​​{"ਟੈਸਟ": "ਜਸਟ"}    

ਜੇ ਤੁਸੀਂ ਹੁਣ ਸਥਾਨਕ ਪੱਧਰ 'ਤੇ ਐਨਪੀਐਮ ਟੈਸਟ ਚਲਾਉਂਦੇ ਹੋ, ਤੁਹਾਨੂੰ ਆਪਣੇ ਟੈਸਟਾਂ ਨੂੰ ਵੇਖਣਾ ਚਾਹੀਦਾ ਹੈ, ਅਤੇ ਪਾਸ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ!

     PASS __ਟੇਸਟ __ / ਸਟੇਟ ਫੰਕਸ਼ਨ. ਟੈਸਟ ਜੇ ਐਸਵਧੀਕ✓ ਜਾਣਦਾ ਹੈ ਕਿ 2 ਅਤੇ 2 ਨੂੰ 4 (5 ਮਿ.ਟੈਸਟ ਸਹੂਲਤਾਂ: 1 ਪਾਸ ਹੋਇਆ, ਕੁੱਲ 1ਟੈਸਟ: 1 ਪਾਸ ਹੋਇਆ, 1 ਕੁੱਲਸਨੈਪਸ਼ਾਟ: 0 ਪਾਸ ਕੀਤੇ, ਕੁੱਲ 0ਸਮਾਂ: 3. 11 ਸ    

ਜੇ ਤੁਸੀਂ ਕਦੇ ਜੈਸਮੀਨ ਜਾਂ ਜ਼ਿਆਦਾਤਰ ਟੈਸਟਿੰਗ ਫਰੇਮਵਰ ਵਰਤੇ ਹਨ, ਤਾਂ ਉਪਰੋਕਤ ਟੈਸਟ ਕੋਡ ਖੁਦ ਹੀ ਜਾਣਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ. ਜਸਟ ਨੇ ਸਾਨੂੰ ਵਰਣਨ ਅਤੇ ਇਸ ਨੂੰ ਆਲ੍ਹਣੇ ਦੇ ਟੈਸਟਾਂ ਲਈ ਵਰਤਣ ਦੀ ਸਹੂਲਤ ਦਿੱਤੀ ਹੈ ਜਿਵੇਂ ਕਿ ਸਾਨੂੰ ਲੋੜ ਹੈ. ਤੁਹਾਨੂੰ ਕਿੰਨੀ ਕੁ ਘੇਰਾਬੰਦੀ ਕਰਨੀ ਹੈ ਤੁਹਾਡੇ 'ਤੇ ਨਿਰਭਰ ਹੈ; ਮੈਂ ਆਲ੍ਹਣਾ ਖਾਂਦਾ ਹਾਂ ਤਾਂ ਜੋ ਵਰਣਨ ਅਤੇ ਇਸ ਨੂੰ ਲਗਭਗ ਇਕ ਵਾਕ ਵਜੋਂ ਪੜ੍ਹਿਆ ਗਿਆ.

ਜਦੋਂ ਅਸਲ ਜਬਰਦਸਤੀ ਕਰਨ ਦੀ ਗੱਲ ਆਉਂਦੀ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਉਸ ਚੀਜ਼ ਨੂੰ ਲਪੇਟ ਕਰਦੇ ਹੋ ਜੋ ਤੁਸੀਂ ਦੀ ਆਸ ਕਾਲ ਵਿਚ, ਉਸ ਤੋਂ ਪਹਿਲਾਂ ਇਕ ਦਾਅਵਾ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਟੈਸਟ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ. ਇਸ ਕੇਸ ਵਿੱਚ, ਅਸੀਂ ਤੋਬੇ ਦਾ ਇਸਤੇਮਾਲ ਕੀਤਾ ਹੈ. ਤੁਸੀਂ ਜੇਸਟ ਡੌਕੂਮੈਂਟੇਸ਼ਨ ਵਿਚਲੇ ਸਾਰੇ ਉਪਲਬਧ ਦਾਅਵਿਆਂ ਦੀ ਸੂਚੀ ਲੱਭ ਸਕਦੇ ਹੋ. ਤੋ ਚੈੱਕ ਕਰਦਾ ਹੈ ਕਿ ਦਿੱਤਾ ਗਿਆ ਮੁੱਲ ਟੈਸਟ ਦੇ ਅਧੀਨ ਮੁੱਲ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ === ਅਜਿਹਾ ਕਰਨ ਲਈ. ਅਸੀਂ ਇਸ ਟਿਊਟੋਰਿਅਲ ਦੇ ਦੁਆਰਾ ਕੁਝ ਜੈਸ ਦੇ ਦਾਅਵਿਆਂ ਨੂੰ ਪੂਰਾ ਕਰਾਂਗੇ.

ਟੈਸਟਿੰਗ ਬਿਜ਼ਨਸ ਲਾਜ਼ੀਿਕ

ਹੁਣ ਅਸੀਂ ਜੇਸਟ ਨੂੰ ਇੱਕ ਡੌਮੀ ਟੈਸਟ 'ਤੇ ਕੰਮ ਕਰਦਿਆਂ ਦੇਖਿਆ ਹੈ, ਆਓ ਇਸ ਨੂੰ ਅਸਲੀ ਖਿਡਾਰੀ' ਤੇ ਚੱਲੀਏ! ਅਸੀਂ ਆਪਣੇ ਰਾਜ ਦੇ ਪਹਿਲੇ ਕਾਰਜਾਂ ਦੀ ਜਾਂਚ ਕਰਨ ਜਾ ਰਹੇ ਹਾਂ, ਟਾਗਲਡਨ . ਟੌਗਲਡੌਨ ਮੌਜੂਦਾ ਸਥਿਤੀ ਅਤੇ ਇੱਕ ਤੌਹੀਨ ਦਾ ID ਹੈ ਜੋ ਅਸੀਂ ਬਦਲਣਾ ਚਾਹੁੰਦੇ ਹਾਂ. ਹਰੇਕ ਟੌਂਡੋ ਵਿਚ ਇਕ ਕੀਤਾ ਜਾਇਦਾਦ ਹੈ ਅਤੇ ਟਾਗਲਡੌਨ ਨੂੰ ਇਸ ਨੂੰ ਸਹੀ ਤੋਂ ਝੂਠਾ , ਜਾਂ ਉਪ-ਉਲਟ

ਜੇ ਤੁਸੀਂ ਇਸ ਦੇ ਨਾਲ ਨਾਲ ਚੱਲ ਰਹੇ ਹੋ, ਤਾਂ ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਤੁਸੀਂ ਰੈਪੋ ਨੂੰ ਨਕਲ ਕੀਤਾ ਹੈ ਅਤੇ ਐਪ ਫੋਲਡਰ ਨੂੰ ਉਸੇ ਡਾਇਰੈਕਟਰੀ ਵਿਚ ਕਾਪੀ ਕੀਤਾ ਹੈ ਜਿਸ ਵਿਚ ਤੁਹਾਡੇ ___ ਟ੍ਰਸਟਸ_ ਫੋਲਡਰ ਸ਼ਾਮਲ ਹਨ. ਤੁਹਾਨੂੰ ਛੋਟੀ ਪੈਕੇਜ ( ਐਨਪੀਐਮ ਇੰਸਟਾਲ ਸ਼ਾਰਟਈਡ --save ) ਨੂੰ ਇੰਸਟਾਲ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੋਏਗਾ, ਜੋ ਕਿ ਟੌਡੋ ਐਪ ਦੀ ਨਿਰਭਰਤਾ ਹੈ.

ਮੈਂ ਇਸ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਐਪ / ਸਟੇਟ ਫੰਕਸ਼ਨ ਤੋਂ ਆਯਾਤ ਕਰਕੇ ਸ਼ੁਰੂ ਕਰਾਂਗਾ. ਜੇ ਐਸ , ਅਤੇ ਟੈਸਟ ਦੇ ਢਾਂਚੇ ਦੀ ਸਥਾਪਨਾ ਜਦੋਂ ਤੁਸੀਂ ਜੈਸ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੇ ਹੋ ਵਰਣਨ ਅਤੇ ਇਸ ਨੂੰ ਆਲ੍ਹਣਾ ਜਿੰਨਾ ਡੂੰਘਾ ਕਰਨਾ ਹੈ, ਤੁਸੀਂ ਵੀ ਟੈਸਟ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ, ਜੋ ਅਕਸਰ ਵਧੀਆ ਪੜ੍ਹਦਾ ਹੈ. ਟੈਸਟ ਸਿਰਫ਼ ਜੈਸਟ ਇਸ ਫੰਕਸ਼ਨ ਲਈ ਉਪਨਾਮ ਹੈ, ਲੇਕਿਨ ਕਈ ਵਾਰ ਪੜਨ-ਲਿਖਣ ਵਿਚ ਅਸਾਨ ਅਤੇ ਨੈਸਟਡ ਘੱਟ

ਉਦਾਹਰਨ ਵਜੋਂ, ਇੱਥੇ ਇਹ ਹੈ ਕਿ ਕਿਵੇਂ ਮੈਂ ਨੇਸਟਡ ਵਰਣਨ ਅਤੇ ਇਸ ਕਾਲਾਂ ਨਾਲ ਇਹ ਟੈਸਟ ਲਿਖਣਾ ਹੈ:

   import {toggleDone} ਤੋਂ '. / ਐਪ / ਸਟੇਟ ਫੰਕਸ਼ਨ ';ਵਰਣਨ ਕਰੋ ('ਟੌਗਲਡੌਨ',    => {ਦਾ ਵਰਣਨ ('ਜਦੋਂ ਇੱਕ ਅਧੂਰਾ ਤੌਦ ਦਿੱਤਾ ਗਿਆ',    => {ਇਹ ('ਮੁਕੰਮਲ ਹੋਣ ਦੇ ਤੌਰ ਤੇ ਟੁੰਡ ਕਰਦਾ ਹੈ',    => {});});});    

ਅਤੇ ਇੱਥੇ ਇਹ ਹੈ ਕਿ ਮੈਂ ਇਹ ਕਿਵੇਂ ਕਰਾਂਗਾ ਟੈਸਟ :

   import {toggleDone} ਤੋਂ '. / ਐਪ / ਸਟੇਟ ਫੰਕਸ਼ਨ ';ਟੈਸਟ ('ਟੌਗਲਡਨ ਨੇ ਇੱਕ ਅਧੂਰੀ ਟੂਡੋ ਪੂਰਾ ਕੀਤੀ',    => {});    

ਟੈਸਟ ਅਜੇ ਵੀ ਵਧੀਆ ਢੰਗ ਨਾਲ ਪੜ੍ਹਦਾ ਹੈ, ਪਰ ਹੁਣ ਸੜਕ 'ਤੇ ਘੱਟ ਉਤਰਨਾ ਹੈ. ਇਹ ਇੱਕ ਮੁੱਖ ਰੂਪ ਵਿੱਚ ਨਿੱਜੀ ਪਸੰਦ ਹੈ; ਉਹ ਸਟਾਈਲ ਚੁਣੋ ਜਿਸ ਨਾਲ ਤੁਸੀਂ ਵਧੇਰੇ ਅਨੁਕੂਲ ਹੋ.

ਹੁਣ ਅਸੀਂ ਦਾਅਵਾ ਲਿਖ ਸਕਦੇ ਹਾਂ. ਪਹਿਲਾਂ ਅਸੀਂ ਇਸ ਨੂੰ ਟੋਗਲ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਟੌਗਲ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ, ਸਾਡਾ ਸ਼ੁਰੂਆਤ ਪ੍ਰਣਾਲੀ ਬਣਾਵਾਂਗੇ, ਜਿਸ ਨਾਲ ਅਸੀਂ ਟੋਗਲ ਦੀ ਆਈਡੀ ਨਾਲ ਟੋਗਲ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਾਂ. ਟੌਗਲਡੌਨ ਸਾਡੀ ਪੂਰਨ ਰਾਜ ਵਾਪਸ ਕਰੇਗਾ, ਜਿਸਦਾ ਅਸੀਂ ਬਾਅਦ ਵਿੱਚ ਦਾਅਵਾ ਕਰ ਸਕਦੇ ਹਾਂ:

   const startState = {todos: [{id: 1, ਕੀਤਾ: ਗਲਤ, ਨਾਮ: 'ਦੁੱਧ ਖਰੀਦੋ'}]};const finState = ਟੌਗਲਡਨ (ਸਟਾਰਟਸਟੇਟ, 1);ਉਮੀਦ ਕਰੋ (ਫਿਨਸਟੇਟ ਟਡੌਡੋਜ਼). toEqual ([{id: 1, ਕੀਤਾ: ਸਹੀ, ਨਾਮ: 'ਦੁੱਧ ਖਰੀਦੋ'}]);    

ਹੁਣ ਧਿਆਨ ਦਿਓ ਕਿ ਮੈਂ ਤੋਂ ਐਕਵਾਲ ਨੂੰ ਆਪਣਾ ਦਾਅਵਾ ਕਰਨ ਲਈ ਵਰਤਦਾ ਹਾਂ. ਤੁਹਾਨੂੰ tobe ਆਰੰਭਿਕ ਮੁੱਲਾਂ ਜਿਵੇਂ ਕਿ ਸਤਰਾਂ ਅਤੇ ਨੰਬਰਾਂ ਆਦਿ 'ਤੇ, ਪਰ ਤੋਂ ਐਕੁਆਲ ਵਸਤੂਆਂ ਅਤੇ ਐਰੇਾਂ ਤੇ ਵਰਤਣਾ ਚਾਹੀਦਾ ਹੈ.

ਉਸਦੇ ਨਾਲ ਅਸੀਂ ਹੁਣ ਐਨਐਮਪੀ ਟੈਸਟ ਚਲਾ ਸਕਦੇ ਹਾਂ ਅਤੇ ਸਾਡਾ ਸਟੇਟ ਫੰਕਸ਼ਨ ਟੈਸਟ ਪਾਸ ਵੇਖੋ:

     PASS __ਟੇਸਟ __ / ਸਟੇਟ ਫੰਕਸ਼ਨ. ਟੈਸਟ ਜੇ ਐਸ✓ ਟੋਗਲ-ਡੋਨ ਇੱਕ ਅਧੂਰੀ ਟੌਂਡੋ (9 ਮਿ.ਟੈਸਟ ਸਹੂਲਤਾਂ: 1 ਪਾਸ ਹੋਇਆ, ਕੁੱਲ 1ਟੈਸਟ: 1 ਪਾਸ ਹੋਇਆ, 1 ਕੁੱਲਸਨੈਪਸ਼ਾਟ: 0 ਪਾਸ ਕੀਤੇ, ਕੁੱਲ 0ਸਮਾਂ: 3. 166 ਸਕਿੰਟ    

ਬਦਲਾਵਾਂ ਤੇ ਸ਼ਾਨਦਾਰ ਟੈਸਟ

ਟੈਸਟ ਫਾਈਲ ਵਿੱਚ ਬਦਲਾਵ ਕਰਨ ਲਈ ਇਹ ਥੋੜਾ ਨਿਰਾਸ਼ਾਜਨਕ ਹੈ ਅਤੇ ਫਿਰ ਖੁਦ ਨੂੰ ਐਨਪੀਐਮ ਟੈਸਟ ਨੂੰ ਚਲਾਉਣਾ ਪਵੇਗਾ. ਜਸਟ ਦੀ ਸਭ ਤੋਂ ਵਧੀਆ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਵਿਚੋਂ ਇਕ ਹੈ ਇਸ ਦੀ ਘੜੀ ਮੋਡ, ਜੋ ਫਾਈਲ ਵਿਚ ਬਦਲਾਵ ਦੇਖਦੀ ਹੈ ਅਤੇ ਉਸ ਅਨੁਸਾਰ ਟੈੱਸਟ ਚਲਾਉਂਦੀ ਹੈ. ਇਹ ਇਸ ਗੱਲ ਦਾ ਸੰਖੇਪ ਵੀ ਕਰ ਸਕਦਾ ਹੈ ਕਿ ਫਾਇਲ ਨੂੰ ਬਦਲਣ ਵਾਲੇ ਟੈਸਟਾਂ ਦੇ ਅਧਾਰ ਤੇ ਕਿਹੜੇ ਟੈਸਟਾਂ ਨੂੰ ਬਦਲਣਾ ਹੈ ਇਹ ਬਹੁਤ ਸ਼ਕਤੀਸ਼ਾਲੀ ਅਤੇ ਭਰੋਸੇਮੰਦ ਹੈ, ਅਤੇ ਤੁਸੀਂ ਜਾਸਟ ਵਿੱਚ ਜਾਗ ਮੋਡ ਨੂੰ ਚਲਾਉਣ ਦੇ ਯੋਗ ਹੋ ਅਤੇ ਜਦੋਂ ਤੁਸੀਂ ਆਪਣਾ ਕੋਡ ਬਣਾਉਂਦੇ ਹੋ ਸਾਰਾ ਦਿਨ ਇਸਨੂੰ ਛੱਡ ਦਿੰਦੇ ਹੋ

ਇਸ ਨੂੰ ਵਾਚ ਮੋਡ ਵਿੱਚ ਚਲਾਉਣ ਲਈ, ਤੁਸੀਂ ਐਨਪੀਐਮ ਟੈਸਟ - --ਵਚ ਨੂੰ ਚਲਾ ਸਕਦੇ ਹੋ. ਜੋ ਵੀ ਤੁਸੀਂ ਪਾਸ ਕਰਦੇ ਹੋ ਐਨਪੀਐਮ ਟੈਸਟ ਪਹਿਲੇ ਦੇ ਬਾਅਦ - ਸਿੱਧੇ ਦੁਆਰਾ ਅੰਡਰਲਾਈੰਗ ਕਮਾਂਡ ਨੂੰ ਪਾਸ ਕੀਤਾ ਜਾਵੇਗਾ. ਇਸ ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਇਹ ਦੋ ਹੁਕਮ ਅਸਰਦਾਰ ਤਰੀਕੇ ਨਾਲ ਬਰਾਬਰ ਹਨ:

  • ਐਨਪੀਐਮ ਟੈਸਟ - --ਹੌਚ
  • ਜਸਟ - ਵਾਚ

ਮੈਂ ਇਸ ਸਿਫ਼ਾਰਸ਼ ਦੀ ਸਿਫ਼ਾਰਿਸ਼ ਕਰਾਂਗਾ ਕਿ ਤੁਸੀਂ ਬਾਕੀ ਟਿਉਟੋਰਿਅਲ ਲਈ ਜੇਸਟ ਦੀ ਦੂਜੀ ਟੈਬ ਜਾਂ ਟਰਮੀਨਲ ਵਿੰਡੋ ਵਿਚ ਚੱਲ ਰਹੇ ਹੋ.

ਰੀੈਕਟ ਕੰਪੋਨੈਂਟਸ ਦੀ ਜਾਂਚ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ, ਅਸੀਂ ਸਾਡੇ ਸਟੇਟ ਫੰਕਸ਼ਨਾਂ ਵਿੱਚੋਂ ਇਕ ਹੋਰ ਟੈਸਟ ਲਈ ਇਕ ਹੋਰ ਟੈਸਟ ਲਿਖਾਂਗੇ. ਅਸਲ ਅਰਜ਼ੀ ਵਿੱਚ ਮੈਂ ਕਈ ਹੋਰ ਟੈਸਟ ਲਿਖਾਂਗਾ, ਪਰ ਟਿਊਟੋਰਿਅਲ ਦੀ ਮਦਦ ਲਈ ਮੈਂ ਉਨ੍ਹਾਂ ਵਿੱਚੋਂ ਕੁਝ ਨੂੰ ਛੱਡਾਂਗੀ. ਹੁਣ ਲਈ, ਆਓ ਇਕ ਟੈਸਟ ਲਿਖੀਏ ਜੋ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਸਾਡੀ ਡਿਲੀਟੋਡੋ ਫੰਕਸ਼ਨ ਕੰਮ ਕਰ ਰਹੀ ਹੈ. ਇਹ ਵੇਖਣ ਤੋਂ ਪਹਿਲਾਂ ਕਿ ਮੈਂ ਇਸਨੂੰ ਕਿਵੇਂ ਲਿਖਿਆ ਹੈ, ਇਸ ਨੂੰ ਖੁਦ ਲਿਖਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੋ ਅਤੇ ਦੇਖੋ ਕਿ ਤੁਹਾਡੀ ਟੈਸਟ ਦੀ ਤੁਲਨਾ ਕਿਵੇਂ ਕਰਦੀ ਹੈ

ਮੈਨੂੰ ਟੈਸਟ ਦਿਖਾਓ

ਯਾਦ ਰੱਖੋ ਕਿ ਤੁਹਾਨੂੰ ਅਯਾਤ ਦੇ ਅਖੀਰ ਨੂੰ ਡਿਲੀਟੋਡੋ ਨੂੰ ਟਾਗਲ ਟਾਡੋ ਦੇ ਨਾਲ ਅਯਾਤ ਕਰਨ ਲਈ :

   ਇੰਪੋਰਟ ਕਰੋ {toggleTodo, deleteTodo} 'ਤੋਂ'. / ਐਪ / ਸਟੇਟ ਫੰਕਸ਼ਨ ';     

ਅਤੇ ਇੱਥੇ ਸੇਮਟ ਨੇ ਟੈਸਟ ਕਿਵੇਂ ਲਿਖਿਆ ਹੈ:

   ਪ੍ਰੀਖਿਆ ('ਡਿਲੀਟੋਡੋ ਟੂਡੌ ਨੂੰ ਦੁੱਗਣੀ ਕਰ ਦਿੰਦਾ ਹੈ',    = & gt; {const startState = {todos: [{id: 1, ਕੀਤਾ: ਗਲਤ, ਨਾਮ: 'ਦੁੱਧ ਖਰੀਦੋ'}]};const finState = deleteTodo (ਸਟਾਰਟਸਟੇਟ, 1);ਉਮੀਦ ਕਰੋ (ਫਿਨਸਟੇਟ ਟਡੌਡੋਜ਼). toEqual ([]);});    

ਪ੍ਰੀਖਿਆ ਪਹਿਲੇ ਤੋਂ ਬਹੁਤ ਜ਼ਿਆਦਾ ਨਹੀਂ ਹੈ: ਅਸੀਂ ਆਪਣੀ ਸ਼ੁਰੂਆਤੀ ਅਵਸਥਾ ਨਿਰਧਾਰਤ ਕਰਦੇ ਹਾਂ, ਆਪਣੇ ਕੰਮ ਨੂੰ ਚਲਾਉਂਦੇ ਹਾਂ ਅਤੇ ਫਿਰ ਸੰਪੂਰਨ ਰਾਜ ਉੱਤੇ ਦਾਅਵਾ ਕਰਦੇ ਹਾਂ. ਜੇ ਤੁਸੀਂ ਜਾਸਟ ਦੀ ਵਾਕ ਮੋਡ ਤੋਂ ਬਾਹਰ ਚਲੇ ਗਏ, ਧਿਆਨ ਦਿਓ ਕਿ ਇਹ ਤੁਹਾਡੀ ਨਵੀਂ ਜਾਂਚ ਕਿਵੇਂ ਕਰਦਾ ਹੈ ਅਤੇ ਇਸ ਨੂੰ ਚਲਾਉਂਦਾ ਹੈ, ਅਤੇ ਇਹ ਕਿੰਨੀ ਕੁ ਤੇਜ਼ ਕਰਨਾ ਹੈ! ਆਪਣੇ ਟੈਸਟਾਂ ਦੇ ਤੁਰੰਤ ਫੀਡਬੈਕ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਇੱਕ ਵਧੀਆ ਤਰੀਕਾ ਮਿਲਾਓ ਜਦੋਂ ਤੁਸੀਂ ਉਨ੍ਹਾਂ ਨੂੰ ਲਿਖਦੇ ਹੋ.

ਉਪਰੋਕਤ ਟੈਸਟ ਇੱਕ ਟੈਸਟ ਲਈ ਸੰਪੂਰਣ ਲੇਆਉਟ ਦਾ ਪ੍ਰਦਰਸ਼ਨ ਵੀ ਕਰਦੇ ਹਨ, ਜੋ:

  • ਸੈਟ ਅਪ
  • ਟੈਸਟ ਅਧੀਨ ਕਾਰਜ ਨੂੰ ਚਲਾਓ
  • ਨਤੀਜੇ 'ਤੇ ਜ਼ੋਰ ਦਿੰਦੇ ਹਨ.

ਇਸ ਤਰੀਕੇ ਨਾਲ ਟੈਸਟ ਕਰਵਾ ਕੇ, ਤੁਸੀਂ ਉਨ੍ਹਾਂ ਦੀ ਪਾਲਣਾ ਕਰਨਾ ਅਸਾਨ ਅਤੇ ਕੰਮ ਕਰੋਗੇ.

ਹੁਣ ਅਸੀਂ ਆਪਣੇ ਸਟੇਟ ਫੰਕਸ਼ਨਾਂ ਦੀ ਜਾਂਚ ਕਰ ਕੇ ਖੁਸ਼ ਹਾਂ, ਆਓ ਅਸੀਂ ਸਾਮਾਲ ਭਾਗਾਂ ਤੇ ਚੱਲੀਏ.

ਟੈਸਟ ਕਰਨ ਵਾਲੇ ਅਨੁਪਾਤ

ਇਹ ਧਿਆਨ ਦੇਣ ਯੋਗ ਹੈ ਕਿ, ਡਿਫਾਲਟ ਤੌਰ ਤੇ, ਮੈਂ ਤੁਹਾਨੂੰ ਤੁਹਾਡੇ ਸੈਮਟੈਂਟ ਕੰਪੋਨੈਂਟਸ ਤੇ ਬਹੁਤ ਸਾਰੇ ਟੈਸਟ ਨਹੀਂ ਲਿਖਣ ਲਈ ਉਤਸ਼ਾਹਿਤ ਕਰਾਂਗਾ. ਜੋ ਕੁਝ ਵੀ ਤੁਸੀਂ ਬਹੁਤ ਚੰਗੀ ਤਰ੍ਹਾਂ ਟੈਸਟ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਜਿਵੇਂ ਕਿ ਕਾਰੋਬਾਰੀ ਲਾਜ਼ਿਕ, ਤੁਹਾਡੇ ਕੰਪੋਨੈਂਟਸ ਵਿੱਚੋਂ ਖਿੱਚੀਆਂ ਜਾਣੀਆਂ ਚਾਹੀਦੀਆਂ ਹਨ ਅਤੇ ਇੱਕਲੇ ਫੰਕਸ਼ਨਾਂ ਵਿੱਚ ਬੈਠਣਾ ਚਾਹੀਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ ਰਾਜ ਦੇ ਕੰਮ ਜੋ ਅਸੀਂ ਪਹਿਲਾਂ ਟੈਸਟ ਕੀਤੇ ਸਨ ਉਸ ਨੇ ਕਿਹਾ ਕਿ, ਕੁਝ ਸਮਾਲ ਇੰਟਰੈਕਸ਼ਨਾਂ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ ਕਈ ਵਾਰ ਲਾਭਦਾਇਕ ਹੁੰਦਾ ਹੈ (ਇਹ ਯਕੀਨੀ ਬਣਾਉਣਾ ਕਿ ਇੱਕ ਖਾਸ ਫੰਕਸ਼ਨ ਨੂੰ ਸਹੀ ਦਲੀਲਾਂ ਨਾਲ ਬੁਲਾਇਆ ਜਾਂਦਾ ਹੈ ਜਦੋਂ ਉਪਭੋਗਤਾ ਇੱਕ ਬਟਨ ਤੇ ਕਲਿਕ ਕਰਦਾ ਹੈ). ਅਸੀਂ ਇਹ ਜਾਂਚ ਕਰ ਕੇ ਸ਼ੁਰੂ ਕਰਾਂਗੇ ਕਿ ਸਾਡੇ ਸਮਾਲਟ ਦੇ ਹਿੱਸੇ ਸਹੀ ਡੇਟਾ ਪੇਸ਼ ਕਰਦੇ ਹਨ, ਅਤੇ ਫਿਰ ਜਾਂਚਾਂ ਦੀ ਜਾਂਚ ਕਰਦੇ ਹਨ ਫਿਰ ਅਸੀਂ ਜੈੱਫ ਦੀ ਇੱਕ ਵਿਸ਼ੇਸ਼ਤਾ ਨੂੰ ਸ਼ੋਪਸ਼ਿਪਾਂ ਤੇ ਲੈ ਜਾਵਾਂਗੇ, ਜੋ ਕਿ ਸਾਮਾਲ ਸਮੱਗਰੀ ਦਾ ਉਤਪਾਦਨ ਹੋਰ ਜ਼ਿਆਦਾ ਸੁਵਿਧਾਜਨਕ ਬਣਾਉਂਦਾ ਹੈ. ਅਸੀਂ ਐਂਨਜਾਈਮ ਵੀ ਸਥਾਪਤ ਕਰਾਂਗੇ, ਇੱਕ ਰੇਪਰ ਲਾਇਬਰੇਰੀ ਜੋ ਏਅਰਬਨੇਬੀ ਦੁਆਰਾ ਲਿਖੀ ਗਈ ਹੈ ਜੋ ਪ੍ਰੀਖਿਆ ਬਣਾਉਂਦਾ ਹੈ ਹਿੱਸੇ ਨੂੰ ਬਹੁਤ ਸੌਖਾ ਬਣਾਉਂਦਾ ਹੈ. ਅਸੀਂ ਸਾਡੇ ਸਾਰੇ ਟੈਸਟਾਂ ਵਿੱਚ ਇਸ API ਨੂੰ ਵਰਤਾਂਗੇ ਐਨਜ਼ਾਈਮ ਇੱਕ ਸ਼ਾਨਦਾਰ ਲਾਇਬ੍ਰੇਰੀ ਹੈ, ਅਤੇ ਪ੍ਰਤੀਕਰਮ ਟੀਮ ਇਹ ਵੀ ਇਸ ਗੱਲ ਦੀ ਸਿਫਾਰਸ਼ ਕਰਦੀ ਹੈ ਕਿ ਟੈਸਟ ਕੰਪੋਨੈਂਟਸ

     npm ਇੰਸਟਾਲ --save-dev ਪ੍ਰਤੀਕਰਮ-ਐਡਜੱਸ-ਟੈਸਟ-ਯੂਟਿਲਜ਼ ਐਂਜ਼ਾਈਮ    

ਆਓ ਇਹ ਪਰਖ ਕਰੀਏ ਕਿ ਟੋਡੋ ਭਾਗ ਉਸਦੇ ਪੈਰਾਂ ਦੇ ਪਾਠ ਨੂੰ ਇਕ ਪੈਰਾ ਦੇ ਅੰਦਰ ਪੇਸ਼ ਕਰਦਾ ਹੈ. ਪਹਿਲਾਂ ਅਸੀਂ __ਟੇਸਟਸ __ / ਟੌਡੋ ਬਣਾਵਾਂਗੇ. ਟੈਸਟ ਜੇ ਐਸ , ਅਤੇ ਸਾਡੇ ਹਿੱਸੇ ਨੂੰ ਆਯਾਤ ਕਰੋ:

   ਤੋੋ ਤੋਂ ਆਯਾਤ ਕਰੋ '. / ਐਪ / ਟੂਡੋ ';'ਪ੍ਰਤੀਕਰਮ' ਤੇ ਪ੍ਰਤੀਕਿਰਿਆ ਕਰੋ;'ਐਂਜ਼ਾਈਮ' ਤੋਂ ਆਯਾਤ {mount};ਟੈਸਟ ('ਟੋਡੋ ਕੰਪੋਨੈਂਟ ਟਾਡੋ ਦੇ ਪਾਠ ਨੂੰ ਪੇਸ਼ ਕਰਦਾ ਹੈ',    => {});    

ਮੈਂ ਵੀ ਐਂਜ਼ਾਮ ਤੋਂ ਮਾਊਟ ਆਯਾਤ ਕਰਦਾ ਹਾਂ. ਮਾਊਂਟ ਫੰਕਸ਼ਨ ਨੂੰ ਸਾਡੇ ਕੰਪੋਨੈਂਟ ਨੂੰ ਰੈਂਡਰ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਫਿਰ ਸਾਨੂੰ ਆਉਟਪੁੱਟ ਦੀ ਜਾਂਚ ਕਰਨ ਅਤੇ ਇਸ ਤੇ ਦਾਅਵਾ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ. ਭਾਵੇਂ ਅਸੀਂ ਨੋਡ ਵਿਚ ਸਾਡੇ ਟੈਸਟਾਂ ਨੂੰ ਚਲਾ ਰਹੇ ਹਾਂ, ਅਸੀਂ ਅਜੇ ਵੀ ਅਜਿਹੇ ਟੈਸਟ ਲਿਖ ਸਕਦੇ ਹਾਂ ਜਿਸ ਲਈ ਇੱਕ DOM ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ. ਇਹ ਇਸ ਲਈ ਹੈ ਕਿਉਂਕਿ ਜੈਸ ਨੇ jsdom ਨੂੰ ਸੰਰਚਿਤ ਕਰਦਾ ਹੈ, ਇੱਕ ਲਾਇਬਰੇਰੀ ਜੋ ਨੋਡ ਵਿੱਚ DOM ਲਾਗੂ ਕਰਦਾ ਹੈ. ਇਹ ਬਹੁਤ ਵਧੀਆ ਹੈ ਕਿਉਂਕਿ ਅਸੀਂ DOM ਅਧਾਰਿਤ ਟੈਸਟ ਲਿਖ ਸਕਦੇ ਹਾਂ, ਹਰ ਵਾਰ ਉਸ ਨੂੰ ਟੈਸਟ ਕਰਨ ਲਈ ਇੱਕ ਬਰਾਊਜ਼ਰ ਨੂੰ ਅੱਗ ਲਾਉਣ ਤੋਂ ਬਿਨਾਂ.

ਅਸੀਂ ਟੋਡੋ :

ਨੂੰ ਬਣਾਉਣ ਲਈ ਮਾਊਂਟ ਇਸਤੇਮਾਲ ਕਰ ਸਕਦੇ ਹਾਂ.
   constto todo = {id: 1, ਕੀਤਾ: ਗਲਤ, ਨਾਮ: 'ਦੁੱਧ ਖਰੀਦੋ'};const wrap = ਮਾਊਟ ();    

ਅਤੇ ਫਿਰ ਅਸੀਂ ਰੈਪਰ ਨੂੰ ਕਾਲ ਕਰ ਸਕਦੇ ਹਾਂ. ਪੈਰਾਗ੍ਰਾਫ ਲੱਭਣ ਲਈ , ਇਕ CSS ਚੋਣਕਾਰ ਦੇਣਾ, ਜੋ ਅਸੀਂ Todo ਦੇ ਟੈਕਸਟ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨ ਦੀ ਉਮੀਦ ਕਰ ਰਹੇ ਹਾਂ. ਇਹ API ਤੁਹਾਡੀ ਜਾਮਨੀ ਨੂੰ ਚੇਤੇ ਕਰ ਸਕਦਾ ਹੈ, ਅਤੇ ਇਹ ਡਿਜ਼ਾਇਨ ਦੁਆਰਾ ਹੈ. ਇਹ ਮੇਲਿੰਗ ਤੱਤ ਲੱਭਣ ਲਈ ਰੈਂਡਰ ਕੀਤੇ ਆਉਟਪੁਟ ਦੀ ਖੋਜ ਲਈ ਇੱਕ ਬਹੁਤ ਹੀ ਅਨੁਭਵੀ API ਹੈ.

   const p = ਰੇਪਰ. ਲੱਭੋ ('. ਟੌਗਲ-ਟੋਡੋ');    

ਅਖ਼ੀਰ ਵਿਚ ਅਸੀਂ ਇਹ ਦਾਅਵਾ ਕਰ ਸਕਦੇ ਹਾਂ ਕਿ ਇਸ ਵਿਚਲਾ ਪਾਠ ਮਿਲਕ ਖਰੀਦੋ:

   ਉਮੀਦ (ਪੀ. ਪਾਠ   ). ਟਬੇ ('ਦੁੱਧ ਖਰੀਦੋ');    

ਮਿਮੈਲਟ ਸਾਡੇ ਪੂਰੇ ਟੈਸਟ ਨੂੰ ਛੂੰਹਦਾ ਹੈ ਜਿਵੇਂ ਕਿ:

   ਤੋੋ ਤੋਂ ਆਯਾਤ ਕਰੋ '. / ਐਪ / ਟੂਡੋ ';'ਪ੍ਰਤੀਕਰਮ' ਤੇ ਪ੍ਰਤੀਕਿਰਿਆ ਕਰੋ;'ਐਂਜ਼ਾਈਮ' ਤੋਂ ਆਯਾਤ {mount};ਟੈਸਟ ('ਟੌਡੋਕੰਪਉੱਨਟ ਇਸ ਵਿਚਲੇ ਪਾਠ ਨੂੰ ਪੇਸ਼ ਕਰਦਾ ਹੈ',    => {const todo = {id: 1, ਕੀਤਾ: ਗਲਤ, ਨਾਮ: 'ਦੁੱਧ ਖਰੀਦੋ'};const wrap = ਮਾਊਟ ();const p = ਰੇਪਰ. ਲੱਭੋ ('. ਟੌਗਲ-ਟੋਡੋ');ਉਮੀਦ (ਪੀ. ਪਾਠ   ) ਟਬੇ ('ਦੁੱਧ ਖਰੀਦੋ');});    

ਪਿਊ! ਤੁਸੀਂ ਸ਼ਾਇਦ ਸੋਚੋ ਕਿ ਇਹ ਬਹੁਤ ਵੱਡਾ ਕੰਮ ਹੈ ਅਤੇ ਇਸ ਗੱਲ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ ਕਿ "ਖਰੀਦੋ ਦੁੱਧ" ਨੂੰ ਸਕਰੀਨ ਉੱਤੇ ਰੱਖਿਆ ਗਿਆ ਹੈ, ਅਤੇ, ਵਧੀਆ .ਤੁਸੀਂ ਸਹੀ ਹੋਵੋਗੇ. ਆਪਣੇ ਘੋੜਿਆਂ ਨੂੰ ਹੁਣ ਲਈ ਰੱਖੋ, ਭਾਵੇਂ; ਅਗਲੇ ਭਾਗ ਵਿੱਚ ਅਸੀਂ ਇਸ ਨੂੰ ਬਹੁਤ ਸੌਖਾ ਬਣਾਉਣ ਲਈ ਮਿਡਲ ਡੌਕੈਪਸ਼ਾਟ ਸਮਰੱਥਾ ਦੀ ਵਰਤੋਂ ਕਰਨ ਤੇ ਵੇਖਾਂਗੇ

ਇਸ ਦੌਰਾਨ, ਆਓ ਵੇਖੀਏ ਕਿ ਤੁਸੀਂ ਜਸਟ ਦੀ ਜਾਸੂਸ ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰ ਸਕਦੇ ਹੋ, ਇਹ ਦੱਸਣ ਲਈ ਕਿ ਕਾਰਜਾਂ ਨੂੰ ਖਾਸ ਦਲੀਲਾਂ ਨਾਲ ਕਿਹਾ ਜਾਂਦਾ ਹੈ. ਇਹ ਸਾਡੇ ਕੇਸ ਵਿੱਚ ਫਾਇਦੇਮੰਦ ਹੈ, ਕਿਉਂਕਿ ਸਾਡੇ ਕੋਲ ਟੌਡੋ ਭਾਗ ਹਨ ਜੋ ਦੋ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਵਿਸ਼ੇਸ਼ਤਾ ਦੇ ਤੌਰ ਤੇ ਦਿੱਤਾ ਗਿਆ ਹੈ, ਜਿਸਨੂੰ ਉਪਭੋਗਤਾ ਇੱਕ ਬਟਨ ਤੇ ਕਲਿਕ ਕਰਦਾ ਹੈ ਜਾਂ ਇੰਟਰਐਕਸ਼ਨ ਕਰਦਾ ਹੈ.

ਇਸ ਪ੍ਰੀਖਿਆ ਵਿਚ ਅਸੀਂ ਇਹ ਦਾਅਵਾ ਕਰਨ ਜਾ ਰਹੇ ਹਾਂ ਕਿ ਜਦੋਂ ਟੌਂਡਾ ਨੂੰ ਦਬਾਇਆ ਗਿਆ ਹੈ, ਤਾਂ ਕੰਪੋਨੈਂਟ ਨੂੰ ਕੀਤਾ ਜਾਵੇਗਾ ਬਦਲਾਅ ਇਸ ਨੂੰ ਦਿੱਤਾ ਗਿਆ ਹੈ.

   ਪ੍ਰੀਖਿਆ ('ਟੌਡੋ ਕਾੱਲ ਕੀਤੇ ਗਏ ਬਦਲੇ ਜਾਣ' ਤੇ ਬਦਲੀ ਕਰੋ ',    => {});    

ਅਸੀਂ ਕੀ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਾਂ, ਇੱਕ ਫੰਕਸ਼ਨ ਰੱਖਣਾ ਹੈ ਕਿ ਅਸੀਂ ਇਸ ਦੇ ਕਾੱਲਾਂ ਦਾ ਪਤਾ ਲਗਾ ਸਕਦੇ ਹਾਂ, ਆਰਗੂਮੈਂਟ ਜਿਸ ਨਾਲ ਇਸ ਨੂੰ ਕਿਹਾ ਗਿਆ ਹੈ. ਫਿਰ ਅਸੀਂ ਇਹ ਪਤਾ ਲਗਾ ਸਕਦੇ ਹਾਂ ਕਿ ਜਦੋਂ ਉਪਭੋਗਤਾ ਦੁਕਾਨ ਤੇ ਕਲਿਕ ਕਰਦਾ ਹੈ, ਕੀਤਾ ਚੇਂਜ ਫੰਕਸ਼ਨ ਨੂੰ ਬੁਲਾਇਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਸਹੀ ਆਰਗੂਮਿੰਟ ਨਾਲ ਵੀ ਬੁਲਾਇਆ ਜਾਂਦਾ ਹੈ. ਸ਼ੁਕਰ ਹੈ, ਜੈਸਟ ਜਾਸੂਸਾਂ ਦੇ ਨਾਲ ਬਕਸੇ ਤੋਂ ਬਾਹਰੋਂ ਇਹ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ ਏ ਜਾਸੂਸ ਇਕ ਅਜਿਹਾ ਕੰਮ ਹੈ ਜਿਸਦਾ ਲਾਗੂ ਕਰਨਾ ਤੁਹਾਡੇ ਬਾਰੇ ਨਹੀਂ ਹੈ; ਤੁਸੀਂ ਕੇਵਲ ਇਸ ਗੱਲ ਦੀ ਪਰਵਾਹ ਕਰਦੇ ਹੋ ਕਿ ਕਦੋਂ ਅਤੇ ਕਿਵੇਂ ਇਸਨੂੰ ਬੁਲਾਇਆ ਜਾਂਦਾ ਹੈ. ਇਸ ਬਾਰੇ ਸੋਚੋ ਜਿਵੇਂ ਤੁਸੀਂ ਫੰਕਸ਼ਨ ਤੇ ਜਾਸੂਸੀ ਕਰਦੇ ਹੋ. ਇੱਕ ਬਣਾਉਣ ਲਈ, ਅਸੀਂ ਜਜ਼ਬਾਤੀ ਨੂੰ ਕਹਿੰਦੇ ਹਾਂ. fn :

   ਕਾਂਡ = ਤਬਦੀਲੀ fn   ;    

ਇਹ ਇੱਕ ਅਜਿਹਾ ਫੰਕਸ਼ਨ ਦਿੰਦਾ ਹੈ ਜਿਸਤੇ ਅਸੀਂ ਜਾਸੂਸੀ ਕਰ ਸਕਦੇ ਹਾਂ ਅਤੇ ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰ ਸਕਦੇ ਹਾਂ ਕਿ ਇਸਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਕਿਹਾ ਗਿਆ ਹੈ. fn ;const wrap = ਮਾਊਟ ();

ਅਗਲਾ, ਅਸੀਂ ਆਪਣੇ ਅਨੁਛੇਦ ਨੂੰ ਫਿਰ ਤੋਂ ਲੱਭ ਸਕਦੇ ਹਾਂ, ਜਿਵੇਂ ਕਿ ਪਿਛਲੇ ਟੈਸਟ ਵਿੱਚ:

   const p = ਟੈਸਟਯੂਟਲਾਂ. findRenderedDOMComponentWithClass (ਪੇਸ਼ ਕੀਤਾ, 'ਟੌਗਲ-ਟੋਡੋ');    

ਅਤੇ ਫਿਰ ਅਸੀਂ ਸਿਮੂਲੇਟ ਇਸ 'ਤੇ ਇਕ ਯੂਜਰ ਇਜ਼ਮ ਨੂੰ ਸਮਰੂਪ ਕਰਨ ਲਈ ਕਹਿ ਸਕਦੇ ਹਾਂ ਕਲਿਕ ਨੂੰ ਆਰਗੂਮਿੰਟ ਦੇ ਤੌਰ ਤੇ:

   ਪੀ. ਸਿਮੂਲੇਟ ('ਕਲਿੱਕ');    

ਅਤੇ ਜੋ ਕੁਝ ਵੀ ਬਾਕੀ ਹੈ, ਇਹ ਦਾਅਵਾ ਕਰਦਾ ਹੈ ਕਿ ਸਾਡੇ ਜਾਸੂਸੀ ਫੰਕਸ਼ਨ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਕਿਹਾ ਗਿਆ ਹੈ ਇਸ ਕੇਸ ਵਿਚ, ਅਸੀਂ ਇਸ ਨੂੰ ਟੌਡੋ ਦੀ ID ਨਾਲ ਬੁਲਾਏ ਜਾਣ ਦੀ ਉਮੀਦ ਕਰ ਰਹੇ ਹਾਂ, ਜੋ ਕਿ 1 ਹੈ. ਅਸੀਂ ਦੀ ਉਮੀਦ ਕਰ ਸਕਦੇ ਹਾਂ (ਕੀਤੇ ਗਏ ਬਦਲਾਅ). toBeCalledWith ਇਸਦਾ ਦਾਅਵਾ ਕਰਨ ਲਈ, ਅਤੇ ਇਸ ਦੇ ਨਾਲ ਅਸੀਂ ਸਾਡੇ ਟੈਸਟ ਦੇ ਨਾਲ ਕੰਮ ਕੀਤਾ!

   ਟੈਸਟ ('ਟੌਡੋਕੰਪੇਂਨੰਟ ਕਾਲਾਂ ਕੀਤੇ ਗਏ ਜਦੋਂ ਟੌਂਡੋ ਨੂੰ ਕਲਿੱਕ ਕੀਤਾ ਜਾਂਦਾ ਹੈ',    => {const todo = {id: 1, ਕੀਤਾ: ਗਲਤ, ਨਾਮ: 'ਦੁੱਧ ਖਰੀਦੋ'};const createdChange = jest. fn   ;const wrap = ਮਾਊਟ ();const p = ਰੇਪਰ. ਲੱਭੋ ('. ਟੌਗਲ-ਟੋਡੋ');ਪੀ. ਸਿਮੂਲੇਟ ('ਕਲਿੱਕ');ਉਮੀਦ (ਕੀਤੇ ਗਏ ਬਦਲਾਅ) toBeCalledWith   ;});    

ਸਨੈਪਸ਼ਾਟ ਨਾਲ ਬਿਹਤਰ ਕੰਪੋਨੈਂਟ ਟੈਸਟਿੰਗ

ਮੈਂ ਉਪਰੋਕਤ ਜ਼ਿਕਰ ਕੀਤਾ ਹੈ ਕਿ ਇਹ ਭਾਗਾਂ ਦੇ ਪ੍ਰਤੀਕ੍ਰਿਆ ਦੀ ਜਾਂਚ ਲਈ ਬਹੁਤ ਕੰਮ ਦੀ ਤਰ੍ਹਾਂ ਮਹਿਸੂਸ ਕਰ ਸਕਦਾ ਹੈ, ਖ਼ਾਸ ਤੌਰ ਤੇ ਕੁਝ ਹੋਰ ਵਿਹਾਰਕ ਕਾਰਜਸ਼ੀਲਤਾ (ਜਿਵੇਂ ਪਾਠ ਪੇਸ਼ ਕਰਨਾ). ਰਿਐਕਟਰ ਕੰਪੋਨੈਂਟਸ ਤੇ ਵੱਡੇ ਪੱਧਰ 'ਤੇ ਦਾਅਵਾ ਕਰਨ ਦੀ ਬਜਾਏ, ਜੇਸਟ ਤੁਹਾਨੂੰ ਸਨੈਪਸ਼ਾਟ ਟੈਸਟ ਚਲਾਉਂਦਾ ਹੈ ਮਿਉਟਲ ਗੱਲਬਾਤ ਲਈ ਬਹੁਤ ਲਾਹੇਵੰਦ ਨਹੀਂ ਹਨ (ਇਸ ਮਾਮਲੇ ਵਿੱਚ ਮੈਂ ਅਜੇ ਵੀ ਇੱਕ ਟੈਸਟ ਦੀ ਤਰਜੀਹ ਕਰਦਾ ਹਾਂ ਜਿਵੇਂ ਕਿ ਅਸੀਂ ਹੁਣੇ ਜਿਹੇ ਲਿਖਿਆ ਸੀ), ਪਰ ਇਹ ਜਾਂਚ ਕਰਨ ਲਈ ਕਿ ਤੁਹਾਡੇ ਹਿੱਸੇ ਦਾ ਉਤਪਾਦ ਸਹੀ ਹੈ, ਉਹ ਬਹੁਤ ਸੌਖਾ ਹੈ.

ਜਦੋਂ ਤੁਸੀਂ ਸਨੈਪਸ਼ਾਟ ਟੈਸਟ ਚਲਾਉਂਦੇ ਹੋ, ਤਾਂ ਜੈਸਟ ਟੈਸਟ ਦੇ ਅਧੀਨ ਸੈਮਟੈਂਟ ਕੰਪੋਨੈਂਟ ਰੈਂਡਰ ਕਰਦਾ ਹੈ ਅਤੇ ਨਤੀਜਾ ਇੱਕ JSON ਫਾਈਲ ਵਿੱਚ ਸਟੋਰ ਕਰਦਾ ਹੈ. ਜਦੋਂ ਵੀ ਟੈਸਟ ਚੱਲਦਾ ਹੈ, ਜੈਸਟ ਇਹ ਜਾਂਚ ਕਰੇਗਾ ਕਿ ਸੈਮਟੈਂਟ ਕੰਪੋਨੈਂਟ ਅਜੇ ਵੀ ਸਨੈਪਸ਼ਾਟ ਦੇ ਤੌਰ ਤੇ ਉਹੀ ਆਉਟਪੁੱਟ ਦਿੰਦਾ ਹੈ. ਫਿਰ, ਜਦੋਂ ਤੁਸੀਂ ਇੱਕ ਭਾਗ ਦੇ ਵਿਹਾਰ ਨੂੰ ਬਦਲਦੇ ਹੋ, ਜੇਸਟ ਤੁਹਾਨੂੰ ਦੱਸੇਗੀ ਅਤੇ ਜਾਂ ਤਾਂ:

  • ਤੁਹਾਨੂੰ ਇਹ ਅਹਿਸਾਸ ਹੋ ਜਾਵੇਗਾ ਕਿ ਤੁਸੀਂ ਇੱਕ ਗਲਤੀ ਕੀਤੀ ਹੈ, ਅਤੇ ਤੁਸੀਂ ਕੰਪੋਨੈਂਟ ਨੂੰ ਠੀਕ ਕਰ ਸਕਦੇ ਹੋ, ਤਾਂ ਜੋ ਇਹ ਫਿਰ ਤੋਂ ਸਨੈਪਸ਼ਾਟ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੋਵੇ
  • ਜਾਂ, ਤੁਸੀਂ ਉਦੇਸ਼ ਨੂੰ ਬਦਲਿਆ ਹੈ, ਅਤੇ ਤੁਸੀਂ ਜੇਸਟ ਨੂੰ ਸਨੈਪਸ਼ਾਟ ਅਪਡੇਟ ਕਰਨ ਲਈ ਕਹਿ ਸਕਦੇ ਹੋ.

ਜਾਂਚ ਦੇ ਇਸ ਤਰੀਕੇ ਤੋਂ ਭਾਵ ਹੈ:

  • ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਕਿ ਤੁਹਾਡੇ ਪ੍ਰਤੀਕ ਦੇ ਭਾਗਾਂ ਦੀ ਉਮੀਦ ਅਨੁਸਾਰ ਵਰਤਾਓ ਕਰ ਰਹੇ ਹਨ
  • ਤੁਸੀਂ ਕਦੇ ਵੀ ਕਿਸੇ ਭਾਗ ਦੇ ਵਿਵਹਾਰ ਨੂੰ ਬਦਲੇ ਨਹੀਂ ਕਰ ਸਕਦੇ, ਕਿਉਂਕਿ ਜੇਟ ਦਾ ਅਹਿਸਾਸ ਹੋਵੇਗਾ

ਤੁਹਾਨੂੰ ਆਪਣੇ ਸਾਰੇ ਭਾਗਾਂ ਨੂੰ ਸਨੈਪਸ਼ਾਟ ਕਰਨ ਦੀ ਵੀ ਲੋੜ ਨਹੀਂ ਹੈ. ਵਾਸਤਵ ਵਿੱਚ, ਮੈਂ ਸਰਗਰਮੀ ਨਾਲ ਇਸਦੇ ਵਿਰੁੱਧ ਸਿਫਾਰਸ਼ ਕਰਾਂਗਾ. ਤੁਹਾਨੂੰ ਕੁਝ ਕਾਰਜਸ਼ੀਲਤਾ ਦੇ ਨਾਲ ਭਾਗ ਲੈਣਾ ਚਾਹੀਦਾ ਹੈ ਜੋ ਤੁਹਾਨੂੰ ਅਸਲ ਵਿੱਚ ਕੰਮ ਕਰਨ ਲਈ ਯਕੀਨੀ ਬਣਾਉਣ ਦੀ ਲੋੜ ਹੈ. ਤੁਹਾਡੇ ਸਾਰੇ ਸੰਖੇਪਾਂ ਨੂੰ ਸਨੈਪੈਪਿੰਗ ਕਰਨ ਨਾਲ ਉਹਨਾਂ ਹੌਲੀ ਜਾਂਚਾਂ ਹੋ ਸਕਦੀਆਂ ਹਨ ਜੋ ਉਪਯੋਗੀ ਨਹੀਂ ਹਨ. ਯਾਦ ਰੱਖੋ, ਸਾਮਾਡਲ ਇੱਕ ਬਹੁਤ ਹੀ ਚੰਗੀ ਤਰਾਂ ਜਾਂਚਿਆ ਫਰੇਮਵਰਕ ਹੈ, ਇਸਲਈ ਅਸੀਂ ਯਕੀਨ ਕਰ ਸਕਦੇ ਹਾਂ ਕਿ ਇਹ ਉਮੀਦ ਅਨੁਸਾਰ ਵਰਤਾਓ ਕਰੇਗਾ ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਤੁਸੀਂ ਆਪਣੇ ਕੋਡ ਦੀ ਬਜਾਏ ਫਰੇਮਵਰਕ ਦੀ ਜਾਂਚ ਨਹੀਂ ਕਰਦੇ!

ਸਨੈਪਸ਼ਾਟ ਜਾਂਚ ਨਾਲ ਸ਼ੁਰੂਆਤ ਕਰਨ ਲਈ, ਸਾਨੂੰ ਇੱਕ ਹੋਰ ਨੋਡ ਪੈਕੇਜ ਦੀ ਜ਼ਰੂਰਤ ਹੈ. ਪ੍ਰਤੀਕਰਮ-ਜਾਂਚ-ਰੈਂਡਰਰ ਇੱਕ ਪੈਕੇਜ ਹੈ ਜੋ ਇੱਕ ਰੀੈਕਟ ਕੰਪੋਨੈਂਟ ਲੈਣ ਅਤੇ ਇਸਨੂੰ ਸ਼ੁੱਧ ਸ਼ਮਲਾ ਵਸਤੂ ਦੇ ਰੂਪ ਵਿੱਚ ਪੇਸ਼ ਕਰਨ ਦੇ ਯੋਗ ਹੈ. ਇਸ ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਇਹ ਫਿਰ ਇੱਕ ਫਾਈਲ ਵਿੱਚ ਸੁਰੱਖਿਅਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਅਤੇ ਇਹ ਉਹੀ ਹੈ ਜੋ ਸਾਡੇ ਫੋਟੋਸ਼ੈਪਨਾਂ ਦਾ ਟ੍ਰੈਕ ਰੱਖਣ ਲਈ ਵਰਤਦਾ ਹੈ.

     npm ਇੰਸਟਾਲ --save-dev ਰੀਐਕਸ਼ਨ-ਟੈਸਟ-ਰੈਂਡਰਰ    

ਹੁਣ, ਆਓ ਇਕ ਸਨੈਪਸ਼ਾਟ ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ ਸਾਡੀ ਪਹਿਲੀ ਟੌਡੋ ਕੰਪੋਨੈਂਟ ਟੈਸਟ ਨੂੰ ਮੁੜ ਲਿਖੀਏ. ਹੁਣ ਲਈ, ਟੋਟੋਕੰਪੇਂਨਟ ਕਾਲਾਂ ਦੀ ਕੀਤੀ ਗਈ ਟਿੱਪਣੀ ਕਰੋ ਜਦੋਂ ਟੌਂਡਾ ਨੂੰ ਕਲਿੱਕ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਤਾਂ ਟੈਸਟ ਵੀ ਕਰੋ

ਸਭ ਤੋਂ ਪਹਿਲਾਂ ਤੁਹਾਨੂੰ ਇਹ ਰਿਐਕਟਰ-ਟੈਸਟ ਰੈਂਡਰਰ ਤੇ ਆਯਾਤ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ, ਅਤੇ ਮਾਊਂਟ ਲਈ ਆਯਾਤ ਨੂੰ ਹਟਾਉਣਾ ਚਾਹੀਦਾ ਹੈ. ਉਹ ਦੋਵੇਂ ਨਹੀਂ ਵਰਤੇ ਜਾ ਸਕਦੇ; ਤੁਹਾਨੂੰ ਜਾਂ ਤਾਂ ਇੱਕ ਜਾਂ ਦੂਜੇ ਨੂੰ ਵਰਤਣਾ ਹੈ. ਇਹੀ ਕਾਰਨ ਹੈ ਕਿ ਅਸੀਂ ਹੁਣ ਇਕ ਹੋਰ ਟੈਸਟ ਦੀ ਟਿੱਪਣੀ ਕੀਤੀ ਹੈ. ਬਣਾਉ ();ਉਮੀਦ ਹੈ (ਪੇਸ਼ ਕੀਤਾ ਟੌਜੇਸਨ ). toMatchSnapshot ;});});

ਪਹਿਲੀ ਵਾਰ ਜਦੋਂ ਤੁਸੀਂ ਇਸ ਨੂੰ ਚਲਾਉਂਦੇ ਹੋ, ਜੇਸਟ ਇਹ ਸਮਝਣ ਲਈ ਚੁਸਤ ਹੈ ਕਿ ਇਸ ਭਾਗ ਲਈ ਕੋਈ ਸਨੈਪਸ਼ਾਟ ਨਹੀਂ ਹੈ, ਇਸ ਲਈ ਇਹ ਇਸ ਨੂੰ ਬਣਾਉਂਦਾ ਹੈ. ਆਓ __ਟੇਸਟ __ / __ ਸਨੈਪਸ਼ਾਟ __ / ਟੌਡੋ ਵੱਲ ਦੇਖੀਏ. ਟੈਸਟ ਜੇ ਐਸ ਸਨੈਪ :

   ਨਿਰਯਾਤ ਕਰਦਾ ਹੈ ['ਟੋਡੋ ਕੰਪੋਨੈਂਟ' ਸਹੀ ਤਰੀਕੇ ਨਾਲ ਸਹੀ ਤਰ੍ਹਾਂ ਪੇਸ਼ ਕਰਦਾ ਹੈ 1`] = '  ਦੁੱਧ ਖਰੀਦੋ 

ਮਿਟਾਓ
`;

ਤੁਸੀਂ ਦੇਖ ਸਕਦੇ ਹੋ ਕਿ ਜੇਸਟ ਨੇ ਸਾਡੇ ਲਈ ਆਉਟਪੁੱਟ ਬਚਾ ਲਈ ਹੈ, ਅਤੇ ਹੁਣ ਅਗਲੀ ਵਾਰ ਜਦੋਂ ਅਸੀਂ ਇਸ ਟੈਸਟ ਨੂੰ ਚਲਾਉਂਦੇ ਹਾਂ ਤਾਂ ਇਹ ਜਾਂਚ ਕਰੇਗਾ ਕਿ ਆਉਟਪੁੱਟ ਇੱਕੋ ਜਿਹੇ ਹਨ. ਇਸ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ, ਮੈਂ ਪੈਰਾਗ੍ਰਾਫ ਨੂੰ ਹਟਾ ਕੇ ਭਾਗ ਨੂੰ ਤੋੜ ਦਿਆਂਗਾ, ਜੋ ਕਿ ਪਾਠ ਦੇ ਪਾਠ ਨੂੰ ਰੈਂਡਰ ਕਰਦਾ ਹੈ, ਭਾਵ ਕਿ ਮੈਂ ਟੌਡੋ ਭਾਗ ਤੋਂ ਇਸ ਲਾਈਨ ਨੂੰ ਹਟਾ ਦਿੱਤਾ ਹੈ:

   

=> ਇਹ ਟੌਗਲ ਕਰੋ }> {TODO ਨਾਮ}

ਮਿਥੈਲਟ ਕੀ ਜਸਟ ਕਹਿੰਦਾ ਹੈ:

     ਫੇਲ __ਟੇਸਟ __ / ਟੌਡੋ ਟੈਸਟ ਜੇ ਐਸ● ਟੋਡੋ ਕੰਪੋਨੈਂਟ ਸਹੀ ਢੰਗ ਨਾਲ ਢੁਕਦਾ ਹੈ- ਠੀਕ ਰੈਂਡਰਆਸ (ਮੁੱਲ) toMatchSnapshot   ਪ੍ਰਾਪਤੀ ਮੁੱਲ ਸੰਗ੍ਰਿਹਤ ਸਨੈਪਸ਼ਾਟ ਨਾਲ ਮੇਲ ਨਹੀਂ ਖਾਂਦਾ 1. - ਸਨੈਪਸ਼ਾਟ+ ਮਿਲਿਆ  -   - ਮਿਲਕ ਖਰੀਦੋ-  

ਮਿਟਾਓ
ਇਕਾਈ 'ਤੇ <ਬੇਨਾਮ> (__ਟੇਸਟਜ਼ __ / ਟੌਡੋ ਟੈਸਟ. ਜੇ ਐਸ: 21: 31)ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ. _tickCallback (ਅੰਦਰੂਨੀ / ਪ੍ਰਕਿਰਿਆ / ਅਗਲੇ_ਟਿਕ. js: 103: 7)

ਜੈਸ ਨੂੰ ਅਹਿਸਾਸ ਹੋਇਆ ਕਿ ਇਹ ਸਨੈਪਸ਼ਾਟ ਨਵੇਂ ਭਾਗ ਨਾਲ ਮੇਲ ਨਹੀਂ ਖਾਂਦਾ ਹੈ, ਅਤੇ ਸਾਨੂੰ ਆਊਟਪੁੱਟ ਵਿੱਚ ਦੱਸ ਦਿੰਦਾ ਹੈ. ਜੇ ਸਾਨੂੰ ਲੱਗਦਾ ਹੈ ਕਿ ਇਹ ਤਬਦੀਲੀ ਸਹੀ ਹੈ, ਤਾਂ ਅਸੀਂ -u ਫਲੈਗ ਦੇ ਨਾਲ ਮਖੌਲ ਕਰ ਸਕਦੇ ਹਾਂ, ਜੋ ਸਨੈਪਸ਼ਾਟ ਨੂੰ ਅਪਡੇਟ ਕਰੇਗਾ. ਇਸ ਕੇਸ ਵਿੱਚ, ਹਾਲਾਂਕਿ, ਮੈਂ ਆਪਣੇ ਬਦਲਾਅ ਨੂੰ ਵਾਪਸ ਕਰ ਦਿਆਂਗਾ ਅਤੇ ਜੈਸੇ ਇੱਕ ਵਾਰ ਹੋਰ ਖੁਸ਼ ਹੁੰਦਾ ਹੈ.

ਅੱਗੇ ਅਸੀਂ ਵੇਖ ਸਕਦੇ ਹਾਂ ਕਿ ਅਸੀਂ ਆਪਸ ਵਿਚਲੇ ਮੁਲਾਂਕਣਾਂ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ ਸਨੈਪਸ਼ਾਟ ਟੈਸਟ ਕਰਨ ਲਈ ਕਿਵੇਂ ਵਰਤ ਸਕਦੇ ਹਾਂ. ਤੁਸੀਂ ਪ੍ਰਤੀ ਟੈਸਟ ਵਿੱਚ ਬਹੁਤ ਸਾਰੇ ਸਨੈਪਸ਼ਾਟ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹੋ, ਇਸ ਲਈ ਤੁਸੀਂ ਇਹ ਪਰਖ ਕਰ ਸਕਦੇ ਹੋ ਕਿ ਇੰਟਰੈਕਸ਼ਨ ਤੋਂ ਬਾਅਦ ਆਉਟਪੁੱਟ ਉਮੀਦ ਅਨੁਸਾਰ ਹੈ

ਅਸੀਂ ਅਸਲ ਵਿੱਚ ਜੈਸਟ ਸਨੈਪਸ਼ਾਟ ਰਾਹੀਂ ਸਾਡੇ ਟੌਡੋ ਕੰਪੋਨੈਂਟ ਇੰਟਰੈਕਸ਼ਨਾਂ ਦਾ ਪ੍ਰੀਖਣ ਨਹੀਂ ਕਰ ਸਕਦੇ, ਕਿਉਂਕਿ ਉਹ ਆਪਣੇ ਖੁਦ ਦੇ ਰਾਜ ਨੂੰ ਨਹੀਂ ਪਰੰਤੂ ਕਾਲਬੈਕ ਰੈਂਪ ਨੂੰ ਕਾਲ ਕਰਦੇ ਹਨ ਮੈਂ ਇੱਥੇ ਕੀ ਕੀਤਾ ਹੈ ਸਨੈਪਸ਼ਾਟ ਟੈਸਟ ਨੂੰ ਇੱਕ ਨਵੀਂ ਫਾਈਲ ਵਿੱਚ ਭੇਜੋ, ਟੋਡੋ ਸਨੈਪਸ਼ਾਟ ਟੈਸਟ ਜੇ ਐਸ, ਅਤੇ ਟੂਡੋ ਵਿਚ ਸਾਡੇ ਟਿੰਗਟ ਟੈਸਟ ਨੂੰ ਛੱਡੋ. ਟੈਸਟ ਜੇ ਐਸ ਮੈਨੂੰ ਇੱਕ ਵੱਖਰੀ ਫਾਇਲ ਵਿੱਚ ਸਨੈਪਸ਼ਾਟ ਟੈਸਟ ਨੂੰ ਵੱਖ ਕਰਨ ਲਈ ਇਹ ਲਾਭਦਾਇਕ ਪਾਇਆ ਗਿਆ ਹੈ; ਇਸ ਦਾ ਇਹ ਵੀ ਮਤਲਬ ਹੈ ਕਿ ਰਿਐਕਟਰ-ਟੈਸਟ-ਰੈਂਡਰਰ ਅਤੇ ਰਿਐਕ-ਐਡਜੈਂਸ-ਟੈਸਟ-ਯੂਟਿਲਜ਼ ਦੇ ਵਿਚਾਲੇ ਅਪਵਾਦ ਨਹੀਂ ਮਿਲਦਾ.

ਯਾਦ ਰੱਖੋ, ਮੈਨੂੰ ਤੁਹਾਡੇ ਲਈ ਮਿਡਲ ਤੇ ਉਪਲਬਧ ਟਿਊਟੋਰਿਅਲ ਵਿੱਚ ਜੋ ਵੀ ਕੋਡ ਲਿਖਿਆ ਹੋਇਆ ਹੈ ਉਹ ਤੁਹਾਡੇ ਲਈ ਸਭ ਤੋਂ ਵਧੀਆ ਤਰੀਕਾ ਲੱਭੇਗਾ ਅਤੇ ਸਥਾਨਕ ਪੱਧਰ ਤੇ ਚਲਾਓਗੇ.

ਸਿਫਾਰਸ਼ੀ ਕੋਰਸ

ਸਿੱਟਾ

ਫੇਸਬੁੱਕ ਨੇ ਬਹੁਤ ਸਮਾਂ ਪਹਿਲਾਂ ਜਸਟ ਨੂੰ ਜਾਰੀ ਕੀਤਾ, ਪਰ ਹਾਲ ਹੀ ਵਿੱਚ ਇਹ ਚੁੱਕਿਆ ਗਿਆ ਹੈ ਅਤੇ ਬਹੁਤ ਜ਼ਿਆਦਾ ਕੰਮ ਕੀਤਾ ਗਿਆ ਹੈ ਸਕਾਲਟ ਫਾਸਟ ਜਾਵਾਸਕ੍ਰਿਪਟ ਡਿਵੈਲਪਰਾਂ ਲਈ ਇੱਕ ਪਸੰਦੀਦਾ ਬਣ ਗਿਆ ਹੈ ਅਤੇ ਇਹ ਸਿਰਫ ਵਧੀਆ ਪ੍ਰਾਪਤ ਕਰਨ ਜਾ ਰਿਹਾ ਹੈ ਜੇ ਤੁਸੀਂ ਪਿਛਲੇ ਸਮੇਂ ਜੇਸਟ ਦੀ ਕੋਸ਼ਿਸ਼ ਕੀਤੀ ਹੈ ਅਤੇ ਇਸ ਨੂੰ ਪਸੰਦ ਨਹੀਂ ਕੀਤਾ ਹੈ, ਤਾਂ ਮੈਂ ਤੁਹਾਨੂੰ ਦੁਬਾਰਾ ਕੋਸ਼ਿਸ਼ ਕਰਨ ਲਈ ਉਤਸ਼ਾਹਿਤ ਨਹੀਂ ਕਰ ਸਕਦਾ, ਕਿਉਂਕਿ ਇਹ ਅਸਲ ਵਿੱਚ ਇੱਕ ਵੱਖਰਾ ਫਰੇਮਵਰਕ ਹੈ ਰੀਮੂਨੀਨਿੰਗ ਐਕਸਕਸ ਤੇ ਤੇਜ਼, ਵਿਟਾਮਿਨ ਮਿਲਾ ਕੇ, ਸ਼ਾਨਦਾਰ ਗਲਤੀ ਸੁਨੇਹੇ ਦਿੰਦਾ ਹੈ ਅਤੇ ਇਸ ਦੇ ਸਨੈਪਸ਼ਾਟ ਦੀ ਕਾਰਜਕੁਸ਼ਲਤਾ ਨਾਲ ਸਭ ਤੋਂ ਉੱਪਰ ਹੈ.

ਜੇ ਤੁਹਾਡੇ ਕੋਈ ਸਵਾਲ ਹਨ, ਤਾਂ ਕਿਰਪਾ ਕਰਕੇ ਸਮਾਲਟ 'ਤੇ ਇਕ ਮੁੱਦਾ ਚੁੱਕਣ ਵਿਚ ਨਾ ਝਿਜਕੋ ਅਤੇ ਮੈਂ ਤੁਹਾਡੀ ਮਦਦ ਕਰਨ ਵਿਚ ਖੁਸ਼ੀ ਮਹਿਸੂਸ ਕਰਾਂਗਾ. ਅਤੇ ਕਿਰਪਾ ਕਰਕੇ ਇਹ ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਸੈਮਵਲ 'ਤੇ ਜੈਸਟ ਦੇਖੋ ਅਤੇ ਪ੍ਰਾਜੈਕਟ ਨੂੰ ਸਟਾਰ ਕਰੋ; ਇਹ ਪ੍ਰਬੰਧਕਾਂ ਨੂੰ ਮਦਦ ਕਰਦਾ ਹੈ

ਡੈਨ ਪ੍ਰਿੰਸ ਅਤੇ ਕ੍ਰਿਸਟੋਫ ਪੋਜ਼ਰ ਦੁਆਰਾ ਇਸ ਲੇਖ ਦੀ ਸਮੀਖਿਆ ਕੀਤੀ ਗਈ ਸੀ. com / avatar / aea964cf59c0c81fff752896f070cbbb? s = 96 ਅਤੇ d = mm ਅਤੇ r = g "alt ="ਯੇਸਟ ਦਾ ਇ

March 1, 2018