Por que getComputedStyle () em um teste JEST retorna resultados diferentes para estilos computados no DevTools do Chrome / Firefox

16

Eu escrevi um botão personalizado ( MyStyledButton) baseado em material-ui Button .

import React from "react";
import { Button } from "@material-ui/core";
import { makeStyles } from "@material-ui/styles";

const useStyles = makeStyles({
  root: {
    minWidth: 100
  }
});

function MyStyledButton(props) {
  const buttonStyle = useStyles(props);
  const { children, width, ...others } = props;

  return (

      <Button classes={{ root: buttonStyle.root }} {...others}>
        {children}
      </Button>
     );
}

export default MyStyledButton;

É estilizado usando um tema e isso especifica backgroundColorque seja um tom de amarelo (Especificamente #fbb900)

import { createMuiTheme } from "@material-ui/core/styles";

export const myYellow = "#FBB900";

export const theme = createMuiTheme({
  overrides: {
    MuiButton: {
      containedPrimary: {
        color: "black",
        backgroundColor: myYellow
      }
    }
  }
});

O componente é instanciado no meu principal index.jse envolvido no theme.

  <MuiThemeProvider theme={theme}>
     <MyStyledButton variant="contained" color="primary">
       Primary Click Me
     </MyStyledButton>
  </MuiThemeProvider>

Se eu examinar o botão no Chrome DevTools, ele background-colorserá "calculado" conforme o esperado. Este também é o caso do Firefox DevTools.

Captura de tela do Chrome

No entanto, quando escrevo um teste JEST para verificar background-colore consulta o estilo do nó DOM - no botão usando getComputedStyles(), transparentvolto e o teste falha.

const wrapper = mount(
    <MyStyledButton variant="contained" color="primary">
      Primary
    </MyStyledButton>
  );
  const foundButton = wrapper.find("button");
  expect(foundButton).toHaveLength(1);
  //I want to check the background colour of the button here
  //I've tried getComputedStyle() but it returns 'transparent' instead of #FBB900
  expect(
    window
      .getComputedStyle(foundButton.getDOMNode())
      .getPropertyValue("background-color")
  ).toEqual(myYellow);

Incluí um CodeSandbox com o problema exato, o código mínimo a ser reproduzido e o teste JEST com falha.

Editar headless-snow-nyofd

Simon Long
fonte
A cor de fundo .MuiButtonBase-root-33 é transparente, enquanto a cor .MuiButton-containsPrimary-13 não é - o problema é que as classes em CSS são igualmente importantes, portanto, apenas a ordem de carga as distingue -> nos estilos de teste são carregados na ordem errada.
Zydnar 18/12/19
11
@Andreas - Atualizado conforme solicitado
Simon Long
@Zyndar - Sim, eu sei disso. Existe alguma maneira de fazer esse teste passar?
Simon Long
A themenecessidade não seria usada no teste? Como, envolva o <MyStyledButton>no <MuiThemeProvider theme={theme}>? Ou use alguma função de wrapper para adicionar o tema a todos os componentes?
Brett DeWoody
Não, isso não faz diferença.
Simon Long

Respostas:

1

Cheguei mais perto, mas ainda não estou em uma solução.

O principal problema é que o MUIButton injeta uma tag no elemento para alimentar os estilos. Isso não está acontecendo no seu teste de unidade. Consegui fazer isso funcionar usando o createMount usado pelos testes de material.

Após essa correção, o estilo está aparecendo corretamente. No entanto, o estilo calculado ainda não funciona. Parece que outras pessoas tiveram problemas ao lidar com enzimas corretamente - então não tenho certeza se é possível.

Para chegar onde eu estava, pegue seu snippet de teste, copie-o para o topo e altere seu código de teste para:

const myMount = createMount({ strict: true });
  const wrapper = myMount(
    <MuiThemeProvider theme={theme}>
      <MyStyledButton variant="contained" color="primary">
        Primary
      </MyStyledButton>
    </MuiThemeProvider>
  );
class Mode extends React.Component {
  static propTypes = {
    /**
     * this is essentially children. However we can't use children because then
     * using `wrapper.setProps({ children })` would work differently if this component
     * would be the root.
     */
    __element: PropTypes.element.isRequired,
    __strict: PropTypes.bool.isRequired,
  };

  render() {
    // Excess props will come from e.g. enzyme setProps
    const { __element, __strict, ...other } = this.props;
    const Component = __strict ? React.StrictMode : React.Fragment;

    return <Component>{React.cloneElement(__element, other)}</Component>;
  }
}

// Generate an enhanced mount function.
function createMount(options = {}) {

  const attachTo = document.createElement('div');
  attachTo.className = 'app';
  attachTo.setAttribute('id', 'app');
  document.body.insertBefore(attachTo, document.body.firstChild);

  const mountWithContext = function mountWithContext(node, localOptions = {}) {
    const strict = true;
    const disableUnnmount = false;
    const localEnzymeOptions = {};
    const globalEnzymeOptions = {};

    if (!disableUnnmount) {
      ReactDOM.unmountComponentAtNode(attachTo);
    }

    // some tests require that no other components are in the tree
    // e.g. when doing .instance(), .state() etc.
    return mount(strict == null ? node : <Mode __element={node} __strict={Boolean(strict)} />, {
      attachTo,
      ...globalEnzymeOptions,
      ...localEnzymeOptions,
    });
  };

  mountWithContext.attachTo = attachTo;
  mountWithContext.cleanUp = () => {
    ReactDOM.unmountComponentAtNode(attachTo);
    attachTo.parentElement.removeChild(attachTo);
  };

  return mountWithContext;
}
AnilRedshift
fonte