Enzima: ¿Cómo acceder y configurar el valor <input>?

Estoy confundido acerca de cómo acceder al <input>valor cuando lo uso mount. Esto es lo que tengo como prueba:

  it('cancels changes when user presses esc', done => {
    const wrapper = mount(<EditableText defaultValue="Hello" />);
    const input = wrapper.find('input');

    console.log(input.render().attr('value'));
    input.simulate('focus');
    done();
  });

Se imprime la consola undefined. Pero si modifico ligeramente el código, funciona:

  it('cancels changes when user presses esc', done => {
    const wrapper = render(<EditableText defaultValue="Hello" />);
    const input = wrapper.find('input');

    console.log(input.val());
    input.simulate('focus');
    done();
  });

Excepto, por supuesto, que la input.simulatelínea falla ya que la estoy usando renderahora. Necesito que ambos funcionen correctamente. ¿Cómo puedo solucionar esto?

EDITAR :

Debo mencionar <EditableText />que no es un componente controlado. Pero cuando paso defaultValueen <input />, al parecer para ajustar el valor. El segundo bloque de código anterior imprime el valor y, de la misma manera, si inspecciono el elemento de entrada en Chrome y escribo $0.valueen la consola, muestra el valor esperado.

Creo que lo que quieres es:

input.simulate('change', { target: { value: 'Hello' } })

Aquí está mi fuente .

No debería necesitar usar render()ningún lugar para establecer el valor. Y solo para su información, está utilizando dos diferentes render(). El que está en su primer bloque de código es de Enzyme, y es un método en el objeto envoltorio mounty le findproporciona. El segundo, aunque no está 100% claro, es probablemente el de react-dom. Si está utilizando la enzima, sólo tiene que utilizar shallowo mountsegún el caso y no hay necesidad de renderpartir react-dom.

Con la Enzima 3 , si necesita cambiar un valor de entrada pero no necesita onChangeactivar la función, simplemente puede hacer esto (la nodepropiedad ha sido eliminada ):

wrapper.find('input').instance().value = "foo";

Puede usar wrapper.find('input').simulate("change", { target: { value: "foo" }})para invocar onChangesi tiene un accesorio para eso (es decir, para componentes controlados).

Entendido. (versión actualizada / mejorada)

  it('cancels changes when user presses esc', done => {
    const wrapper = mount(<EditableText defaultValue="Hello" />);
    const input = wrapper.find('input');

    input.simulate('focus');
    input.simulate('change', { target: { value: 'Changed' } });
    input.simulate('keyDown', {
      which: 27,
      target: {
        blur() {
          // Needed since <EditableText /> calls target.blur()
          input.simulate('blur');
        },
      },
    });
    expect(input.get(0).value).to.equal('Hello');

    done();
  });

Hay muchas opiniones diferentes aquí. Lo único que funcionó para mí fue nada de lo anterior, estaba usando input.props().value. Espero que eso ayude.

Estoy usando create-react-app que viene con jest por defecto y enzima 2.7.0.

Esto funcionó para mí:

const wrapper = mount(<EditableText defaultValue="Hello" />);
const input = wrapper.find('input')[index]; // where index is the position of the input field of interest
input.node.value = 'Change';
input.simulate('change', input);
done();

Ninguno de los anteriores funcionó para mí. Esto es lo que funcionó para mí en Enzyme ^ 3.1.1:

input.instance().props.onChange(({ target: { value: '19:00' } }));

Aquí está el resto del código para el contexto:

const fakeHandleChangeValues = jest.fn();
  const fakeErrors = {
    errors: [{
      timePeriod: opHoursData[0].timePeriod,
      values: [{
        errorIndex: 2,
        errorTime: '19:00',
      }],
    }],
    state: true,
  };
const wrapper = mount(<AccessibleUI
    handleChangeValues={fakeHandleChangeValues}
    opHoursData={opHoursData}
    translations={translationsForRendering}
  />);
const input = wrapper.find('#input-2').at(0);
input.instance().props.onChange(({ target: { value: '19:00' } }));
expect(wrapper.state().error).toEqual(fakeErrors);

Estoy usando react con TypeScript y lo siguiente funcionó para mí

wrapper.find('input').getDOMNode<HTMLInputElement>().value = 'Hello';
wrapper.find('input').simulate('change');

Establecer el valor directamente

wrapper.find('input').instance().value = 'Hello'` 

me estaba provocando una advertencia de compilación.

Esto me funciona usando la enzima 2.4.1:

const wrapper = mount(<EditableText defaultValue="Hello" />);
const input = wrapper.find('input');

console.log(input.node.value);

aquí está mi código ..

const input = MobileNumberComponent.find('input')
// when
input.props().onChange({target: {
   id: 'mobile-no',
   value: '1234567900'
}});
MobileNumberComponent.update()
const Footer = (loginComponent.find('Footer'))
expect(Footer.find('Buttons').props().disabled).equals(false)

He actualizado mi DOM con componentname.update() Y luego verifiqué la validación del botón de envío (deshabilitar / habilitar) con una longitud de 10 dígitos.

En mi caso, estaba usando devoluciones de llamada de referencia,

  <input id="usuario" className="form-control" placeholder="Usuario"
                                                       name="usuario" type="usuario"
                                                       onKeyUp={this._validateMail.bind(this)}
                                                       onChange={()=> this._validateMail()}
                                                       ref={(val) =>{ this._username = val}}
                                                    >

Para obtener el valor. Así que la enzima no cambiará el valor de this._username.

Entonces tuve que:

login.node._username.value = "mario@com.com";
    user.simulate('change');
    expect(login.state('mailValid')).toBe(true);

Para poder establecer el valor, llame al cambio. Y luego afirmar.

Esto funcionó para mí:

let wrapped = mount(<Component />);
expect(wrapped.find("input").get(0).props.value).toEqual("something");

En caso de que alguien tenga dificultades, encontré lo siguiente que me funciona

const wrapper = mount(<NewTask {...props} />); // component under test
const textField = wrapper.find(TextField);

textField.props().onChange({ target: { value: 'New Task 2' } })
textField.simulate('change');
// wrapper.update() didn't work for me, need to find element again

console.log(wrapper.find(TextField).props()); // New Task 2

Parece que primero debe definir lo que sucede en el evento de cambio y luego simularlo (en lugar de simular el evento de cambio con datos)

Resolví de una manera muy simple:

1. Establezca el valor de los accesorios :

  const wrapper: ShallowWrapper = shallow(<ProfileViewClass name: 'Sample Name' />);

2. Código HTML :

  <input type='text' defaultValue={props.name} className='edituser-name' />

3. Acceda al atributo desde wrapper.find(element).props().attribute-name:

  it('should render user name', () => {
    expect(wrapper.find('.edituser-name').props().defaultValue).toContain(props.name);
  });

Salud

Ninguna de las soluciones anteriores funcionó para mí porque estaba usando Formik y necesitaba marcar el campo como "tocado" junto con cambiar el valor del campo. El siguiente código funcionó para mí.

const emailField = orderPageWrapper.find('input[name="email"]')

emailField.simulate('focus')
emailField.simulate('change', { target: { value: 'test@example.com', name: 'email' } })
emailField.simulate('blur')

Utilizo el método setValue [ https://vue-test-utils.vuejs.org/api/wrapper/#setvalue-value] de Wrapper para establecer el valor.

inputA = wrapper.findAll('input').at(0)
inputA.setValue('123456')

.simulate()no funciona para mí de alguna manera, lo hice funcionar con solo acceder node.valuesin necesidad de llamar .simulate(); en tu caso:

const wrapper = mount(<EditableText defaultValue="Hello" />);
const input = wrapper.find('input').at(0);

// Get the value
console.log(input.node.value); // Hello

// Set the value
input.node.value = 'new value';

// Get the value
console.log(input.node.value); // new value

¡Espero que esto ayude a los demás!