summaryrefslogtreecommitdiffstats
path: root/sdc-os-chef
diff options
context:
space:
mode:
authorSatoshi Fujii <fujii-satoshi@jp.fujitsu.com>2020-02-21 16:19:55 +0900
committerSatoshi Fujii <fujii-satoshi@jp.fujitsu.com>2020-02-21 16:24:07 +0900
commitc5411baf4fe1354e6a70742c9d2d33b6b5fdc12e (patch)
treeae978e8d1a1e8bf89927de8dfe8b09c06f38fadb /sdc-os-chef
parent32f485b151dba9e40e6b1171c246bf8f3e9c8fc4 (diff)
Fix logging date format to avoid parse error
When MDCSetup class in logging-filter-base tries to calculate an elapsed time, it expects a datetime is given in ISO format. But date format in LogFieldsMdcHandler is not compatible with ISO format therefore 'Unable to calculate elapsed time due to error' occurs. This change fixes date format in the class so that the date string can be parsed by logging-filter. Change-Id: I07c8f103f46493fe0764f904f3f00f66f35dbcf6 Issue-ID: SDC-2767 Signed-off-by: Satoshi Fujii <fujii-satoshi@jp.fujitsu.com>
Diffstat (limited to 'sdc-os-chef')
0 files changed, 0 insertions, 0 deletions
7'>127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 
/*
 * Copyright © 2016-2018 European Support Limited
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import React from 'react';
import { mount } from 'enzyme';
import { cloneAndSet } from 'test-utils/Util.js';
import ActivityLogView, {
    ActivityListItem
} from 'sdc-app/common/activity-log/ActivityLogView.jsx';
import ListEditorView from 'nfvo-components/listEditor/ListEditorView.jsx';
import ActivityLogActionHelper from 'sdc-app/common/activity-log/ActivityLogActionHelper.js';
import { mapStateToProps } from 'sdc-app/common/activity-log/ActivityLog.js';
import { storeCreator } from 'sdc-app/AppStore.js';
import mockRest from 'test-utils/MockRest.js';
import { ActivityLogStoreFactory } from 'test-utils/factories/activity-log/ActivityLogFactories.js';
import VersionFactory from 'test-utils/factories/common/VersionFactory.js';
import { UserFactory } from 'test-utils/factories/users/UsersFactories.js';

import { actionTypes as userActionTypes } from 'sdc-app/onboarding/users/UsersConstants.js';

describe('Activity Log Module Tests', function() {
    const LICENSE_MODEL_ID = '555';
    const version = VersionFactory.build();
    const usersList = UserFactory.buildList(3);

    it('mapStateToProps mapper exists', () => {
        expect(mapStateToProps).toBeTruthy();
    });

    it('Loads Activity Log and renders into jsx', () => {
        const store = storeCreator();
        const dispatch = store.dispatch;
        dispatch({
            type: userActionTypes.USERS_LIST_LOADED,
            usersList
        });
        let ActivityLogList = ActivityLogStoreFactory.buildList(1, {
            user: usersList[0].userId
        });
        const expectedStore = cloneAndSet(
            store.getState(),
            'licenseModel.activityLog',
            ActivityLogList
        );

        mockRest.addHandler('fetch', ({ data, options, baseUrl }) => {
            expect(baseUrl).toEqual(
                `/onboarding-api/v1.0/items/${LICENSE_MODEL_ID}/versions/${
                    version.id
                }/activity-logs`
            );
            expect(data).toEqual(undefined);
            expect(options).toEqual(undefined);
            return { results: ActivityLogList };
        });

        return ActivityLogActionHelper.fetchActivityLog(dispatch, {
            itemId: LICENSE_MODEL_ID,
            versionId: version.id
        }).then(() => {
            const state = store.getState();
            expect(state).toEqual(expectedStore);
            const props = mapStateToProps(state);
            expect(props.activities).toEqual(
                ActivityLogList.map(activity => ({
                    ...activity,
                    user: {
                        id: activity.user,
                        name: usersList.find(
                            userObject => userObject.userId === activity.user
                        ).fullName
                    }
                }))
            );
            const wrapper = mount(<ActivityLogView {...props} />);
            expect(wrapper).toBeTruthy();
        });
    });

    it('Tests Activity Log filter and sorting abilities', () => {
        const firstDate = new Date();
        const secondDate = new Date();
        secondDate.setDate(firstDate.getDate() - 1);

        const firstTimestamp = firstDate.getTime();
        const secondTimestamp = secondDate.getTime();

        let firstActivity = ActivityLogStoreFactory.build({
            user: usersList[0].userId,
            timestamp: firstTimestamp
        });
        let secondActivity = ActivityLogStoreFactory.build({
            user: usersList[1].userId,
            timestamp: secondTimestamp,
            status: { success: false, message: 'error' }
        });
        let props = mapStateToProps({
            users: { usersList },
            licenseModel: { activityLog: [firstActivity, secondActivity] }
        });
        const wrapper = mount(<ActivityLogView {...props} />);
        expect(wrapper.find(ActivityListItem).length).toEqual(3); // Includes Header component

        const firstInstance = wrapper.find(ActivityListItem).at(1);
        const firstInstanceProps = firstInstance.props();
        expect(firstInstanceProps.activity.timestamp).toEqual(secondTimestamp); // Default sorting is descending

        const header = wrapper.find(ActivityListItem).at(0);

        header.props().onSort();
        wrapper.update();
        const newFirstInstance = wrapper.find(ActivityListItem).at(1);
        const newFirstInstanceProps = newFirstInstance.props();
        expect(newFirstInstanceProps.activity.timestamp).toEqual(
            firstTimestamp
        );

        const listEditor = wrapper.find(ListEditorView);
        listEditor.props().onFilter(usersList[1].fullName);
        wrapper.update();
        expect(wrapper.find(ActivityListItem).length).toEqual(2);
        expect(
            wrapper
                .find(ActivityListItem)
                .at(1)
                .props().activity.user.name
        ).toEqual(usersList[1].fullName);
    });
});