Merge pull request #88 from nglvnyls/Traduccio-API-Test-Renderer

Traduccio API- Test Renderer

content/docs/reference-test-renderer.md

@@ -1,25 +1,25 @@
 ---
 id: test-renderer
-title: Test Renderer
+title: Test de Renderitzat
 permalink: docs/test-renderer.html
 layout: docs
 category: Reference
 ---
 
-**Importing**
+**Fent la Importació**
 
 ```javascript
 import TestRenderer from 'react-test-renderer'; // ES6
-const TestRenderer = require('react-test-renderer'); // ES5 with npm
+const TestRenderer = require('react-test-renderer'); // ES5 amb npm
 ```
 
-## Overview {#overview}
+## Resum {#overview}
 
-This package provides a React renderer that can be used to render React components to pure JavaScript objects, without depending on the DOM or a native mobile environment.
+Aquest paquet proporciona un renderitzador de React que es pot fer servir per representar els components de React a objectes JavaScript purs, sense dependre del DOM o d'un entorn mòbil natiu.
 
-Essentially, this package makes it easy to grab a snapshot of the platform view hierarchy (similar to a DOM tree) rendered by a React DOM or React Native component without using a browser or [jsdom](https://github.com/tmpvar/jsdom).
+Essencialment, aquest paquet facilita la captura de la jerarquia de visualització de la plataforma (similar a un DOM) renderitzada per a un DOM o un component natiu de React sense fer servir un navegador o [jsdom](https://github.com/tmpvar/jsdom).
 
-Example:
+Exemple:
 
 ```javascript
 import TestRenderer from 'react-test-renderer';
@@ -38,9 +38,9 @@ console.log(testRenderer.toJSON());
 //   children: [ 'Facebook' ] }
 ```
 
-You can use Jest's snapshot testing feature to automatically save a copy of the JSON tree to a file and check in your tests that it hasn't changed: [Learn more about it](https://jestjs.io/docs/en/snapshot-testing).
+Pots fer servir la funció d'instantània de test de Jest per desar automàticament una còpia de l'arbre JSON a un fitxer i comprovar als teus test que no ha canviat: [Aprèn més sobre això](https://jestjs.io/docs/en/snapshot-testing).
 
-You can also traverse the output to find specific nodes and make assertions about them.
+També pots recórrer el resultat per trobar nodes específics i fer-hi afirmacions.
 
 ```javascript
 import TestRenderer from 'react-test-renderer';
@@ -72,7 +72,7 @@ expect(testInstance.findByProps({className: "sub"}).children).toEqual(['Sub']);
 * [`TestRenderer.create()`](#testrenderercreate)
 * [`TestRenderer.act()`](#testrendereract)
 
-### TestRenderer instance {#testrenderer-instance}
+### Instàncies de TestRenderer {#testrenderer-instance}
 
 * [`testRenderer.toJSON()`](#testrenderertojson)
 * [`testRenderer.toTree()`](#testrenderertotree)
@@ -95,43 +95,43 @@ expect(testInstance.findByProps({className: "sub"}).children).toEqual(['Sub']);
 * [`testInstance.parent`](#testinstanceparent)
 * [`testInstance.children`](#testinstancechildren)
 
-## Reference {#reference}
+## Referència {#reference}
 
 ### `TestRenderer.create()` {#testrenderercreate}
 
 ```javascript
 TestRenderer.create(element, options);
 ```
 
-Create a `TestRenderer` instance with the passed React element. It doesn't use the real DOM, but it still fully renders the component tree into memory so you can make assertions about it. Returns a [TestRenderer instance](#testrenderer-instance).
+Crea una instància `TestRenderer` amb l'element React passat. No fa servir el DOM real, però tot i així renderitza completament l'arbre del component a la memòria perquè puguis fer afirmacions sobre aquest. Retorna una instància [TestRenderer](#testrenderer-instance).
 
 ### `TestRenderer.act()` {#testrendereract}
 
 ```javascript
 TestRenderer.act(callback);
 ```
 
-Similar to the [`act()` helper from `react-dom/test-utils`](/docs/test-utils.html#act), `TestRenderer.act` prepares a component for assertions. Use this version of `act()` to wrap calls to `TestRenderer.create` and `testRenderer.update`.
+Semblant a l'assistent [`act()` de `react-dom/test-utils`](/docs/test-utils.html#act), `TestRenderer.act` prepara un component per a fer-hi afirmacions. Utilitza aquesta versió de `act()` per envoltar les crides a `TestRenderer.create` i `testRenderer.update`.
 
 ```javascript
 import {create, act} from 'react-test-renderer';
-import App from './app.js'; // The component being tested
+import App from './app.js'; // El component sobre el que es fa el test
 
-// render the component
+// renderitza el component
 let root; 
 act(() => {
   root = create(<App value={1}/>)
 });
 
-// make assertions on root 
+// fer afirmacions al root 
 expect(root.toJSON()).toMatchSnapshot();
 
-// update with some different props
+// actualitzar-lo amb algun atribut diferent
 act(() => {
   root.update(<App value={2}/>);
 })
 
-// make assertions on root 
+// fer afirmacions al root 
 expect(root.toJSON()).toMatchSnapshot();
 ```
 
@@ -141,141 +141,141 @@ expect(root.toJSON()).toMatchSnapshot();
 testRenderer.toJSON()
 ```
 
-Return an object representing the rendered tree. This tree only contains the platform-specific nodes like `<div>` or `<View>` and their props, but doesn't contain any user-written components. This is handy for [snapshot testing](https://facebook.github.io/jest/docs/en/snapshot-testing.html#snapshot-testing-with-jest).
+Retorna un objecte que representa l'arbre renderitzat. Aquest arbre només conté els nodes específics de la plataforma com `<div>` o `<View>` i els seus atributs, però no conté cap component escrit per l'usuari. És útil per a les [proves d'instantània](https://facebook.github.io/jest/docs/en/snapshot-testing.html#snapshot-testing-with-jest).
 
 ### `testRenderer.toTree()` {#testrenderertotree}
 
 ```javascript
 testRenderer.toTree()
 ```
 
-Return an object representing the rendered tree. The representation is more detailed than the one provided by `toJSON()`, and includes the user-written components. You probably don't need this method unless you're writing your own assertion library on top of the test renderer.
+Retorna un objecte que representa l'arbre renderitzat. La representació és més detallada que la proporcionada per `toJSON()`, i inclou els components escrits per l'usuari. Probablement no necessitaràs aquest mètode excepte que estiguis escrivint la teva pròpia biblioteca d'afirmacions sobre el renderitzador de test. 
 
 ### `testRenderer.update()` {#testrendererupdate}
 
 ```javascript
 testRenderer.update(element)
 ```
 
-Re-render the in-memory tree with a new root element. This simulates a React update at the root. If the new element has the same type and key as the previous element, the tree will be updated; otherwise, it will re-mount a new tree.
+Torna a renderitzar l'arbre en memòria amb un nou element arrel. Això simula una actualització de React a l'arrel. Si el nou element té el mateix tipus i clau que l'element anterior, l'arbre s'actualitzarà; en cas contrari, es tornarà a muntar un nou arbre.
 
 ### `testRenderer.unmount()` {#testrendererunmount}
 
 ```javascript
 testRenderer.unmount()
 ```
 
-Unmount the in-memory tree, triggering the appropriate lifecycle events.
+Desmunta l'arbre en memòria, desencadenant els esdeveniments de cicle de vida apropiats.
 
 ### `testRenderer.getInstance()` {#testrenderergetinstance}
 
 ```javascript
 testRenderer.getInstance()
 ```
 
-Return the instance corresponding to the root element, if available. This will not work if the root element is a function component because they don't have instances.
+Retorna la instància corresponent a l'element arrel, si està disponible. No funcionarà si l'element arrel és un component de funció perquè aquests no tenen instàncies.
 
 ### `testRenderer.root` {#testrendererroot}
 
 ```javascript
 testRenderer.root
 ```
 
-Returns the root "test instance" object that is useful for making assertions about specific nodes in the tree. You can use it to find other "test instances" deeper below.
+Retorna l'objecte arrel «instància de test» que és útil per fer afirmacions sobre nodes específics de l'arbre. Pots utilitzar-lo per trobar altres "instàncies de test" aigües avall.
 
 ### `testInstance.find()` {#testinstancefind}
 
 ```javascript
 testInstance.find(test)
 ```
 
-Find a single descendant test instance for which `test(testInstance)` returns `true`. If `test(testInstance)` does not return `true` for exactly one test instance, it will throw an error.
+Cerca una única instància de test aigües avall per a la qual `test(testInstance)` retorna `true`. Si `test(testInstance)` no retorna `true` per a una i només una instància de test, es llançarà un error.
 
 ### `testInstance.findByType()` {#testinstancefindbytype}
 
 ```javascript
 testInstance.findByType(type)
 ```
 
-Find a single descendant test instance with the provided `type`. If there is not exactly one test instance with the provided `type`, it will throw an error.
+Cerca una única instància de test aigües avall amb el tipus `type` proporcionat. Si no hi ha exactament una instància de test amb el `type` proporcionat, es llançarà un error.
 
 ### `testInstance.findByProps()` {#testinstancefindbyprops}
 
 ```javascript
 testInstance.findByProps(props)
 ```
 
-Find a single descendant test instance with the provided `props`. If there is not exactly one test instance with the provided `props`, it will throw an error.
+Cerca una única instància de test aigües avall amb les `props` proporcionades. Si no hi ha exactament una i només una instància de test amb les `props` proporcionades, es produirà un error.
 
 ### `testInstance.findAll()` {#testinstancefindall}
 
 ```javascript
 testInstance.findAll(test)
 ```
 
-Find all descendant test instances for which `test(testInstance)` returns `true`.
+Cerca totes les instàncies de test aigües avall per a les quals `test(testInstance)` retorna `true`.
 
 ### `testInstance.findAllByType()` {#testinstancefindallbytype}
 
 ```javascript
 testInstance.findAllByType(type)
 ```
 
-Find all descendant test instances with the provided `type`.
+Cerca totes les instàncies de test aigües avall amb el `type` proporcionat.
 
 ### `testInstance.findAllByProps()` {#testinstancefindallbyprops}
 
 ```javascript
 testInstance.findAllByProps(props)
 ```
 
-Find all descendant test instances with the provided `props`.
+Cerca totes les instàncies de test aigües avall amb les `props` proporcionades..
 
 ### `testInstance.instance` {#testinstanceinstance}
 
 ```javascript
 testInstance.instance
 ```
 
-The component instance corresponding to this test instance. It is only available for class components, as function components don't have instances. It matches the `this` value inside the given component.
+La instància del component corresponent a aquesta instància de test. Només està disponible per als components de classe, ja que els components de la funció no tenen instàncies. Coincideix amb el valor  `this` dins del component indicat.
 
 ### `testInstance.type` {#testinstancetype}
 
 ```javascript
 testInstance.type
 ```
 
-The component type corresponding to this test instance. For example, a `<Button />` component has a type of `Button`.
+El tipus de component que corresponent a aquesta instància de test. Per exemple, un component `<Button />`  té un tipus de `Button`.
 
 ### `testInstance.props` {#testinstanceprops}
 
 ```javascript
 testInstance.props
 ```
 
-The props corresponding to this test instance. For example, a `<Button size="small" />` component has `{size: 'small'}` as props.
+Les *props* corresponents a aquesta instància de test. Per exemple, un component `<Button size="small" />` té  com a *props* `{size: 'small'}`.
 
 ### `testInstance.parent` {#testinstanceparent}
 
 ```javascript
 testInstance.parent
 ```
 
-The parent test instance of this test instance.
+La instància de test pare d'aquesta instància de test.
 
 ### `testInstance.children` {#testinstancechildren}
 
 ```javascript
 testInstance.children
 ```
 
-The children test instances of this test instance.
+Les instàncies de test filles d'aquesta instància de test.
 
-## Ideas {#ideas}
+## Idees {#ideas}
 
-You can pass `createNodeMock` function to `TestRenderer.create` as the option, which allows for custom mock refs.
-`createNodeMock` accepts the current element and should return a mock ref object.
-This is useful when you test a component that relies on refs.
+Pots passar la funció `createNodeMock` a `TestRenderer.create` com a opció, que permet fer simulacions de referències personalitzades.
+`createNodeMock` accepta l'element actual i retornarà un objecte ref simulat.
+És útil quan proves un component que es té referències.
 
 ```javascript
 import TestRenderer from 'react-test-renderer';
@@ -299,7 +299,7 @@ TestRenderer.create(
   {
     createNodeMock: (element) => {
       if (element.type === 'input') {
-        // mock a focus function
+        // simula una funció d'enfocament
         return {
           focus: () => {
             focused = true;