nexshop-web-contents/spec/component/dialog/confirm-overwrite-contents-item/confirm-overwrite-contents-item-spec.js

Nexshop Web Contents Project

import React from 'react';
import {expect} from 'chai';
import {shallow} from "enzyme";
import configureStore from 'redux-mock-store';
import sinon from 'sinon';
import * as Redux from "redux";
import {actions as dialogActions} from "nexshop-web-dialog";
import ConfirmOverwriteContentsItem from '../../../../src/component/dialog/confirm-overwrite-contents-item/confirm-overwrite-contents-item';
import {contentsActions} from "nexshop-web-store";

describe('Confirm Delete Contents Item Spec', () => {
    let dialogWrapper;
    let wrapper;
    let mockStore;
    let mockActions;
    let dialogInstance;
    let mockOnClose;

    const {closeDialog} = dialogActions;
    const {
        uploadFilesAsync,
        uploadFileExist,
        setBehaviorExistFile,
        willBeOverwroteContentItem,
        updateFilesAsync,
    } = contentsActions;

    const selectedUploadFiles = [
        {type: 'image/png', name: "exist content"},
        {type: 'video/mp4', name: "new content"}
    ];
    const willOverwriteContent = [{...selectedUploadFiles[0], index: 0}];

    beforeEach(() => {
        mockOnClose = sinon.spy();

        mockActions = {
            closeDialog: sinon.spy(),
            uploadFilesAsync: sinon.spy(),
            uploadFileExist: sinon.spy(),
            setBehaviorExistFile: sinon.spy(),
            willBeOverwroteContentItem: sinon.spy(),
            updateFilesAsync: sinon.spy(),
        };

        sinon.stub(Redux, "bindActionCreators").returns({
            closeDialog: mockActions.closeDialog,
            uploadFilesAsync: mockActions.uploadFilesAsync,
            uploadFileExist: mockActions.uploadFileExist,
            setBehaviorExistFile: mockActions.setBehaviorExistFile,
            willBeOverwroteContentItem: mockActions.willBeOverwroteContentItem,
            updateFilesAsync: mockActions.updateFilesAsync,
        });

        mockStore = configureStore()({
            dialog: 'overwrite-contents-item',
            contents: {
                selectedUploadFiles,
                willOverwriteContent,
                behaviorExistFile: 'NONE',
            }
        });
        dialogWrapper = shallow(<ConfirmOverwriteContentsItem store={mockStore}/>).dive();

        wrapper = shallow(<ConfirmOverwriteContentsItem.WrappedDialogComponent actions={mockActions}
                                                                               onClose={mockOnClose}
                                                                               selectedUploadFiles={selectedUploadFiles}
                                                                               willOverwriteContent={willOverwriteContent}
                                                                               behaviorExistFile={'NONE'}
        />);
        dialogInstance = dialogWrapper.instance();
    });

    afterEach(() => {
        Redux.bindActionCreators.restore();
    });

    describe('Mapping Props', () => {
        describe('not used contents item case', () => {

            it('has visibility true when redux state dialog is "overwrite-contents-item"', () => {
                expect(dialogInstance.props.visibility).to.true;
            });

            it('has selectedUploadFiles', () => {
                expect(dialogInstance.props.selectedUploadFiles).to.equal(selectedUploadFiles);
            });

            it('has willOverwriteContent', () => {
                expect(dialogInstance.props.willOverwriteContent).to.equal(willOverwriteContent);
            });

            it('has behaviorExistFile', () => {
                expect(dialogInstance.props.behaviorExistFile).to.equal('NONE');
            });

            it('binds actionCreator with openDialog, closeDialog, deleteContentsItem', () => {
                let actions = Redux.bindActionCreators.lastCall.args[0];
                const actionsKeys = Object.keys(actions);

                expect(actionsKeys).to.deep.equal([
                    'closeDialog',
                    'uploadFilesAsync',
                    'uploadFileExist',
                    'setBehaviorExistFile',
                    'willBeOverwroteContentItem',
                    'updateFilesAsync']);

                expect(actions.closeDialog).to.equal(closeDialog);
                expect(actions.uploadFilesAsync).to.equal(uploadFilesAsync);
                expect(actions.uploadFileExist).to.equal(uploadFileExist);
                expect(actions.setBehaviorExistFile).to.equal(setBehaviorExistFile);
                expect(actions.willBeOverwroteContentItem).to.equal(willBeOverwroteContentItem);
                expect(actions.updateFilesAsync).to.equal(updateFilesAsync);
            });

            it('has actions openDialog, closeDialog, deleteContentsItem', () => {
                expect(dialogInstance.props.actions).to.deep.equal({
                    closeDialog: mockActions.closeDialog,
                    uploadFilesAsync: mockActions.uploadFilesAsync,
                    uploadFileExist: mockActions.uploadFileExist,
                    setBehaviorExistFile: mockActions.setBehaviorExistFile,
                    willBeOverwroteContentItem: mockActions.willBeOverwroteContentItem,
                    updateFilesAsync: mockActions.updateFilesAsync,
                });
            });
        });

        describe('existed upload file case', () => {
            beforeEach(() => {
                const willOverwriteContent = [{...selectedUploadFiles[0], index: 0, status: 'exist'}];

                mockStore = configureStore()({
                    dialog: 'overwrite-contents-item',
                    contents: {
                        selectedUploadFiles,
                        willOverwriteContent,
                        behaviorExistFile: 'NONE',
                    }
                });

                dialogWrapper = shallow(<ConfirmOverwriteContentsItem store={mockStore}/>).dive();

                wrapper = shallow(<ConfirmOverwriteContentsItem.WrappedDialogComponent actions={mockActions}
                                                                                       onClose={mockOnClose}
                                                                                       selectedUploadFiles={selectedUploadFiles}
                                                                                       willOverwriteContent={willOverwriteContent}
                                                                                       behaviorExistFile={'NONE'}
                />);
                dialogInstance = dialogWrapper.instance();
            });

            it('has exist', () => {
                expect(dialogInstance.props.willOverwriteContent[0].status).to.equal('exist');
            });

            it('has exist message', () => {
                expect(wrapper.find('.confirm-overwrite-contents-item-message').at(0).text()).to.equal('exist content already exist.');
            });

            it('has caption', () => {
                expect(wrapper.find('.confirm-overwrite-contents-item-caption').text()).to.equal('All scenes, playlists, and schedules with this file will be affected.');
            });
        });
    });

    describe('click event', () => {
        it('calls closeDialog action when click SKIP button', () => {
            wrapper.find('.confirm-overwrite-contents-item-footer-button__skip').simulate('click');

            expect(mockActions.closeDialog.called).to.be.true;
        });

        it('calls setBehaviorExistFile when click SKIP button And all apply checked', () => {
            wrapper.setState({
                isApplyToAll: true
            });

            wrapper.find('.confirm-overwrite-contents-item-footer-button__skip').simulate('click');

            expect(mockActions.setBehaviorExistFile.calledWith("SKIP")).to.be.true;
            expect(mockActions.closeDialog.called).to.be.true;
        });

        it('state [isApplyToAll] will change when click checkBox', () => {
            wrapper.setState({
                isApplyToAll: false
            });

            expect(wrapper.instance().state.isApplyToAll).to.equal(false);

            wrapper.find("Checkbox").simulate('check');
            expect(wrapper.instance().state.isApplyToAll).to.equal(true);

            wrapper.find("Checkbox").simulate('check');
            expect(wrapper.instance().state.isApplyToAll).to.equal(false);
        });

        it('calls file update when OVERWRITE button click ', () => {
            wrapper.find('.confirm-overwrite-contents-item-footer-button__overwrite').simulate('click');

            expect(mockActions.updateFilesAsync.called).to.be.true;
            expect(mockActions.closeDialog.called).to.be.true;
        });

        it('calls setBehaviorExistFile when click OVERWRITE button And all apply checked', () => {
            wrapper.setState({
                isApplyToAll: true
            });

            wrapper.find('.confirm-overwrite-contents-item-footer-button__overwrite').simulate('click');

            expect(mockActions.setBehaviorExistFile.calledWith("OVERWRITE")).to.be.true;
            expect(mockActions.closeDialog.called).to.be.true;
        });

    });
});