Comment puis-je tester axios dans la plaisanterie

J'ai cette action de réagir

export function fetchPosts() {
    const request = axios.get(`${WORDPRESS_URL}`);
    return {
        type: FETCH_POSTS,
        payload: request
    }
}

Comment puis-je tester axios dans ce cas? La plaisanterie ont ce cas d'utilisation sur le site pour async code où ils utilisent une maquette de la fonction mais je ne sais pas si je peux le faire avec axios? ref: https://facebook.github.io/jest/docs/tutorial-async.html

Je l'ai fait jusqu'à présent pour tester qu'il est de retour le bon type de

it('should dispatch actions with the correct type', () => {
    store.dispatch(fetchPosts());
    let action = store.getActions();
    expect(action[0].type).toBe(FETCH_POSTS);
});

Je n'ai aucune idée de comment passer dans la maquette de données et d'essais qu'il renvoie cependant, quiconque a des idées?

Je vous remercie à l'avance

github.com/mzabriskie/moxios
Pour mon test, j'ai utilisé le code suivant: gist.github.com/knee-cola/00641c39a268f0b96f1842640b87f3a2. Il est écrit en caractères d'imprimerie, mais peut facilement être converti en vanilla JS

OriginalL'auteur Adear | 2017-07-10

J'ai utilisé axios-modèle d'adaptateur.
Dans ce cas, le service est décrit dans l' ./chatbot.
Dans le simulacre de l'adaptateur de vous indiquer quoi retourner lorsque l'API point de terminaison est consommé.

import axios from 'axios';
import MockAdapter from 'axios-mock-adapter';
import chatbot from './chatbot';

describe('Chatbot', () => {
    it('returns data when sendMessage is called', done => {
        var mock = new MockAdapter(axios);
        const data = { response: true };
        mock.onGet('https://us-central1-hutoma-backend.cloudfunctions.net/chat').reply(200, data);

        chatbot.sendMessage(0, 'any').then(response => {
            expect(response).toEqual(data);
            done();
        });
    });
});

Vous pouvez voir l'ensemble de l'exemple ici:

Service:
https://github.com/lnolazco/hutoma-test/blob/master/src/services/chatbot.js

Test:
https://github.com/lnolazco/hutoma-test/blob/master/src/services/chatbot.test.js

Merci Luis cela m'a aidé beaucoup
Merci pour la solution. Son fonctionnement. est-il possible de tester les api réel de la réponse?

OriginalL'auteur Luis Nolazco

Sans recourir à d'autres bibliothèques:

import * as axios from "axios";

//Mock out all top level functions, such as get, put, delete and post:
jest.mock("axios");

//...

it("good response", () => {
  axios.get.mockImplementation(() => Promise.resolve({ data: {...} }));
  //...
});

it("bad response", () => {
  axios.get.mockImplementation(() => Promise.reject({ ... }));
  //...
});

Il est possible de spécifier le code de réponse:

axios.get.mockImplementation(() => Promise.resolve({ status: 200, data: {...} }));

Il est possible de changer la maquette sur la base de paramètres:

axios.get.mockImplementation((url) => {
    if (url === 'www.example.com') {
        return Promise.resolve({ data: {...} });
    } else {
        //...
    }
});

Voir La blague se moquant de docs pour plus d'info.

Vous pouvez simplifier par il suffit d'écrire jest.mock('axios) dans le même champ d'application que import axios. Puis si la partie de test écrire axios.get.mockResolvedValue({...}) pour résolu une partie et axios.get.mockRejectedValueOnce({...}). Pour en savoir plus: moqueur fonctions doc et github discussion

OriginalL'auteur A Jar of Clay

12

Je pouvais le faire en suivant les étapes:
1. Créer un dossier __se moque__/ (comme indiqué par @Januartha commentaire)
2. De mettre en œuvre un axios.js se moquer de fichier
3. Utiliser mon mis en œuvre sur un module de test
La simulation se fera automatiquement

Exemple de la maquette du module:
```
module.exports = {
    get: jest.fn((url) => {
        if (url === '/something') {
            return Promise.resolve({
                data: 'data'
            });
        }
    }),
    post: jest.fn((url) => {
        if (url === '/something') {
            return Promise.resolve({
                data: 'data'
            });
        }
        if (url === '/something2') {
            return Promise.resolve({
                data: 'data2'
            });
        }
    }),
    create: jest.fn(function () {
        return this;
    })
};
```
comment utilisez-vous cette dans un test. pouvez-vous montrer
Salut @shorif2000 j'ai mis en place ici github.com/vspedr/movile-messaging/pull/8/files
l'écriture manuelle se moque de l'intérieur de objets fantaisie n'est pas une bonne pratique en tant que le manuel se moque de documentation dit à l'écriture manuelle se moque de l'intérieur __se moque__
désolé, pour ma faute de frappe. Je vais le corriger ici. J'ai tapé sur la réponse "____mock___" et il a mis ma parole en gras. Désolé
ah bien sûr, pas de problème 🙂

OriginalL'auteur Amadeu Cavalcante Filho

Je l'ai fait avec nock, comme suit:

import nock from 'nock'
import axios from 'axios'
import httpAdapter from 'axios/lib/adapters/http'

axios.defaults.adapter = httpAdapter

describe('foo', () => {
    it('bar', () => {
        nock('https://example.com:443')
            .get('/example')
            .reply(200, 'some payload')

        //test...
    })
})

J'ai essayé cela, mais je semble que axios ne joue pas bien avec encoche.github.com/node-nock/nock/issues/699 mais je vous remercie pour votre aide, n'en est pas moins

OriginalL'auteur Jon B

Pour ceux qui cherchent à utiliser axios-modèle d'adaptateur à la place de la mockfetch exemple dans le redux documentation pour async test, je l'ai utilisée avec succès la suite de

actions.test.js:

describe('SignInUser', () => {
  var history = {
    push: function(str) {
        expect(str).toEqual('/feed');
    }
  }

  it('Dispatches authorization', () => {
    let mock = new MockAdapter(axios);
    mock.onPost(`${ROOT_URL}/auth/signin`, { 
        email: '[email protected]', 
        password: 'test'
    }).reply(200, {token: 'testToken' });

    const expectedActions = [ { type: types.AUTH_USER } ];
    const store = mockStore({ auth: [] });

    return store.dispatch(actions.signInUser({ 
      email: '[email protected]', 
      password: 'test',
    }, history)).then(() => {
        expect(store.getActions()).toEqual(expectedActions);
  });

});

Afin de tester la réussite de ce cas pour signInUser dans actions/index.js:

export const signInUser = ({ email, password }, history) => async dispatch => {
  const res = await axios.post(`${ROOT_URL}/auth/signin`, { email, password })
    .catch(({ response: { data } }) => {
        ...
  });

  if (res) {
    dispatch({ type: AUTH_USER });                 //test verified this
    localStorage.setItem('token', res.data.token); //test mocked this
    history.push('/feed');                         //test mocked this
  }
}

Étant donné que cela est fait avec une plaisanterie, le localstorage appel à se moque de lui. C'était dans src/setupTests.js:

const localStorageMock = {
  removeItem: jest.fn(),
  getItem: jest.fn(),
  setItem: jest.fn(),
  clear: jest.fn()
};
global.localStorage = localStorageMock;

Comment avez-vous utilisé le localStorageMock
est documenté dans la création de réagir avec l'application mondiale de l'installation pour la plaisanterie/enzyme testing. Dans ce fichier que j'ai créé un objet que j'ai arbitrairement appelé localStorageMock avec des feintes de fonctions (getItem, setItem). La magie est en bas où j'ai mis global.localStorage égal à cet objet. Je pourrais l'ai fait en une seule ligne au lieu de nommer l'objet localStorageMock. Le but de cette installation est de simplement éviter tout code en traitant avec localstorage de se briser en cours de tests.

OriginalL'auteur vapurrmaid

Vous devez vous connecter pour publier un commentaire.