SCM-Manager/scm-ui/ui-webapp/src/repos/sources/modules/sources.test.ts

import { Repository, File } from '@scm-manager/ui-types';
import configureMockStore from 'redux-mock-store';
import thunk from 'redux-thunk';
import fetchMock from 'fetch-mock';
import {
  FETCH_SOURCES,
  FETCH_SOURCES_FAILURE,
  FETCH_SOURCES_PENDING,
  FETCH_SOURCES_SUCCESS,
  fetchSources,
  getFetchSourcesFailure,
  isFetchSourcesPending,
  default as reducer,
  getSources,
  fetchSourcesSuccess,
  isDirectory,
} from './sources';

const sourcesUrl =
  'http://localhost:8081/scm/rest/api/v2/repositories/scm/core/sources/';

const repository: Repository = {
  name: 'core',
  namespace: 'scm',
  type: 'git',
  _links: {
    sources: {
      href: sourcesUrl,
    },
  },
};

const collection = {
  name: 'src',
  path: 'src',
  directory: true,
  description: 'foo',
  length: 176,
  revision: '76aae4bb4ceacf0e88938eb5b6832738b7d537b4',
  subRepository: undefined,
  _links: {
    self: {
      href:
        'http://localhost:8081/scm/rest/api/v2/repositories/scm/core/sources/76aae4bb4ceacf0e88938eb5b6832738b7d537b4/',
    },
  },
  _embedded: {
    children: [
      {
        name: 'src',
        path: 'src',
        directory: true,
        description: '',
        length: 176,
        revision: '76aae4bb4ceacf0e88938eb5b6832738b7d537b4',
        lastModified: '',
        subRepository: undefined,
        _links: {
          self: {
            href:
              'http://localhost:8081/scm/rest/api/v2/repositories/scm/core/sources/76aae4bb4ceacf0e88938eb5b6832738b7d537b4/src',
          },
        },
        _embedded: {
          children: [],
        },
      },
      {
        name: 'package.json',
        path: 'package.json',
        directory: false,
        description: 'bump version',
        length: 780,
        revision: '76aae4bb4ceacf0e88938eb5b6832738b7d537b4',
        lastModified: '2017-07-31T11:17:19Z',
        subRepository: undefined,
        _links: {
          self: {
            href:
              'http://localhost:8081/scm/rest/api/v2/repositories/scm/core/content/76aae4bb4ceacf0e88938eb5b6832738b7d537b4/package.json',
          },
          history: {
            href:
              'http://localhost:8081/scm/rest/api/v2/repositories/scm/core/sources/history/76aae4bb4ceacf0e88938eb5b6832738b7d537b4/package.json',
          },
        },
        _embedded: {
          children: [],
        },
      },
    ],
  },
};

const noDirectory: File = {
  name: 'src',
  path: 'src',
  directory: true,
  length: 176,
  revision: 'abc',
  _links: {
    self: {
      href:
        'http://localhost:8081/scm/rest/api/v2/repositories/scm/core/sources/76aae4bb4ceacf0e88938eb5b6832738b7d537b4/src',
    },
  },
  _embedded: {
    children: [],
  },
};

describe('sources fetch', () => {
  const mockStore = configureMockStore([thunk]);

  afterEach(() => {
    fetchMock.reset();
    fetchMock.restore();
  });

  it('should fetch the sources of the repository', () => {
    fetchMock.getOnce(sourcesUrl, collection);

    const expectedActions = [
      {
        type: FETCH_SOURCES_PENDING,
        itemId: 'scm/core/_/',
      },
      {
        type: FETCH_SOURCES_SUCCESS,
        itemId: 'scm/core/_/',
        payload: collection,
      },
    ];

    const store = mockStore({});
    return store.dispatch(fetchSources(repository, '', '')).then(() => {
      expect(store.getActions()).toEqual(expectedActions);
    });
  });

  it('should fetch the sources of the repository with the given revision and path', () => {
    fetchMock.getOnce(sourcesUrl + 'abc/src', collection);

    const expectedActions = [
      {
        type: FETCH_SOURCES_PENDING,
        itemId: 'scm/core/abc/src',
      },
      {
        type: FETCH_SOURCES_SUCCESS,
        itemId: 'scm/core/abc/src',
        payload: collection,
      },
    ];

    const store = mockStore({});
    return store.dispatch(fetchSources(repository, 'abc', 'src')).then(() => {
      expect(store.getActions()).toEqual(expectedActions);
    });
  });

  it('should dispatch FETCH_SOURCES_FAILURE on server error', () => {
    fetchMock.getOnce(sourcesUrl, {
      status: 500,
    });

    const store = mockStore({});
    return store.dispatch(fetchSources(repository, '', '')).then(() => {
      const actions = store.getActions();
      expect(actions[0].type).toBe(FETCH_SOURCES_PENDING);
      expect(actions[1].type).toBe(FETCH_SOURCES_FAILURE);
      expect(actions[1].itemId).toBe('scm/core/_/');
      expect(actions[1].payload).toBeDefined();
    });
  });
});

describe('reducer tests', () => {
  it('should return unmodified state on unknown action', () => {
    const state = {};
    expect(reducer(state)).toBe(state);
  });

  it('should store the collection, without revision and path', () => {
    const expectedState = {
      'scm/core/_/': collection,
    };
    expect(
      reducer({}, fetchSourcesSuccess(repository, '', '', collection)),
    ).toEqual(expectedState);
  });

  it('should store the collection, with revision and path', () => {
    const expectedState = {
      'scm/core/abc/src/main': collection,
    };
    expect(
      reducer(
        {},
        fetchSourcesSuccess(repository, 'abc', 'src/main', collection),
      ),
    ).toEqual(expectedState);
  });
});

describe('selector tests', () => {
  it('should return false if it is no directory', () => {
    const state = {
      sources: {
        'scm/core/abc/src/main/package.json': {
          noDirectory,
        },
      },
    };
    expect(
      isDirectory(state, repository, 'abc', 'src/main/package.json'),
    ).toBeFalsy();
  });

  it('should return true if it is directory', () => {
    const state = {
      sources: {
        'scm/core/abc/src': noDirectory,
      },
    };
    expect(isDirectory(state, repository, 'abc', 'src')).toBe(true);
  });

  it('should return null', () => {
    expect(getSources({}, repository, '', '')).toBeFalsy();
  });

  it('should return the source collection without revision and path', () => {
    const state = {
      sources: {
        'scm/core/_/': collection,
      },
    };
    expect(getSources(state, repository, '', '')).toBe(collection);
  });

  it('should return the source collection with revision and path', () => {
    const state = {
      sources: {
        'scm/core/abc/src/main': collection,
      },
    };
    expect(getSources(state, repository, 'abc', 'src/main')).toBe(collection);
  });

  it('should return true, when fetch sources is pending', () => {
    const state = {
      pending: {
        [FETCH_SOURCES + '/scm/core/_/']: true,
      },
    };
    expect(isFetchSourcesPending(state, repository, '', '')).toEqual(true);
  });

  it('should return false, when fetch sources is not pending', () => {
    expect(isFetchSourcesPending({}, repository, '', '')).toEqual(false);
  });

  const error = new Error('incredible error from hell');

  it('should return error when fetch sources did fail', () => {
    const state = {
      failure: {
        [FETCH_SOURCES + '/scm/core/_/']: error,
      },
    };
    expect(getFetchSourcesFailure(state, repository, '', '')).toEqual(error);
  });

  it('should return undefined when fetch sources did not fail', () => {
    expect(getFetchSourcesFailure({}, repository, '', '')).toBe(undefined);
  });
});