@capillarytech/creatives-library 8.0.136-alpha.4 → 8.0.136-beta.3

package/containers/Cap/tests/index.test.js

@@ -0,0 +1,22 @@
+import React from 'react';
+import { injectIntl } from 'react-intl';
+import { shallowWithIntl } from '../../../helpers/intl-enzym-test-helpers';
+import {Cap} from '../index';
+import * as actions from '../actions';
+
+describe('<Cap />', () => {
+  const push = jest.fn();
+  const componentProps = {
+    actions,
+    history: {
+      push,
+    },
+    orgTimezone: 'Asia/Kolkata',
+  };
+
+  it('should render its children', () => {
+    const Component = injectIntl(Cap);
+    const renderedComponent = shallowWithIntl(<Component {...componentProps} />);
+    expect(renderedComponent).toMatchSnapshot();
+  });
+});

package/containers/Cap/tests/saga.test.js

@@ -0,0 +1,284 @@
+import { expectSaga } from 'redux-saga-test-plan';
+import { throwError } from 'redux-saga-test-plan/providers';
+import * as matchers from 'redux-saga-test-plan/matchers';
+import {
+  take, fork, cancel, takeLatest,
+} from 'redux-saga/effects';
+import {
+  authorize, loginFlow, logoutFlow, watchForLogoutFlow, capSaga,
+  fetchSchemaForEntity,
+  fetchUserInfo,
+} from '../sagas';
+import * as api from '../../../services/api';
+import {
+  LOGIN_REQUEST,
+  LOGIN_FAILURE,
+  LOGOUT_REQUEST,
+  LOGOUT_SUCCESS,
+  LOGOUT_FAILURE,
+  GET_SCHEMA_FOR_ENTITY_SUCCESS,
+  GET_SCHEMA_FOR_ENTITY_FAILURE,
+  GET_USER_DATA_SUCCESS,
+  GET_USER_DATA_FAILURE,
+} from '../constants';
+
+const error = new Error('error');
+
+describe('fetchUserInfo Saga', () => {
+  it('should handle success scenario', () => {
+    const mockCallback = jest.fn();
+    const mockApiResponse = {
+      user: { id: 1, name: 'Test User' },
+      currentOrgDetails: {
+        basic_details: {
+          base_language: '',
+          supported_languages: [],
+        },
+      },
+      currentOrgId: '123',
+    };
+
+    const expectedUserData = { id: 1, name: 'Test User' };
+    const updatedOrgDetails = {
+      basic_details: {
+        base_language: 'en',
+        supported_languages: [
+          {
+            lang_id: 69,
+            language: 'English',
+            iso_code: 'en',
+          },
+        ],
+      },
+    };
+
+    return expectSaga(fetchUserInfo, { callback: mockCallback })
+      .provide([
+        [matchers.call.fn(api.getUserData), mockApiResponse],
+      ])
+      .call(api.getUserData)
+      .put({
+        type: GET_USER_DATA_SUCCESS,
+        userData: expectedUserData,
+        currentOrgId: '123',
+        currentOrgDetails: {
+          ...mockApiResponse.currentOrgDetails,
+          basic_details: {
+            ...updatedOrgDetails.basic_details,
+          },
+        },
+      })
+      .run();
+  });
+
+  it('should handle failure scenario', () => {
+    const mockCallback = jest.fn();
+    const mockError = new Error('Some error');
+
+    return expectSaga(fetchUserInfo, { callback: mockCallback })
+      .provide([
+        [matchers.call.fn(api.getUserData), throwError(mockError)],
+      ])
+      .call(api.getUserData)
+      .put({
+        type: GET_USER_DATA_FAILURE,
+        error: mockError,
+      })
+      .run();
+  });
+});
+
+describe('capSaga', () => {
+  it("should initialize all capSaga-related watcher sagas without error", () => {
+    return expectSaga(capSaga).run();
+  });
+});
+
+describe('loginFlow', () => {
+  it('should handle the login flow', () => {
+    const generator = loginFlow();
+    const user = { username: 'testuser', password: 'password123' };
+    let task;
+    // First iteration
+    expect(generator.next().value).toEqual(take(LOGIN_REQUEST));
+    expect(generator.next({ user }).value).toEqual(fork(authorize, user));
+    task = generator.next().value; // Assign the task value
+    try {
+      const failureAction = { type: LOGIN_FAILURE };
+
+      expect(generator.next(logoutAction).value).toEqual(cancel(task));
+
+      // When LOGIN_FAILURE action is dispatched
+      expect(generator.next(failureAction).value).toEqual(take(LOGIN_REQUEST));
+      expect(generator.next().value).toEqual(fork(authorize, user));
+      expect(generator.next().done).toBe(true);
+    } catch {}
+  });
+});
+describe('logoutFlow [Unit Test]', () => {
+  describe('logoutFlow saga', () => {
+    it('handle valid response from api', async () => {
+      expectSaga(logoutFlow)
+        .provide([
+          [
+            matchers.call.fn(api.logout),
+            {
+              success: true,
+              message: 'message',
+            },
+          ],
+        ])
+        .put({
+          type: LOGOUT_SUCCESS,
+          result: 'message',
+        })
+        .run();
+    });
+
+    it('handle invalid response from api', async () => {
+      expectSaga(logoutFlow)
+        .provide([
+          [
+            matchers.call.fn(api.logout),
+            {
+              success: false,
+              message: 'message',
+            },
+          ],
+        ])
+        .run();
+    });
+
+    it('handle error response from api', async () => {
+      expectSaga(logoutFlow)
+        .provide([
+          [
+            matchers.call.fn(api.logout),
+            {
+              success: false,
+              error,
+            },
+          ],
+        ])
+        .put({
+          type: LOGOUT_FAILURE,
+          error,
+        })
+        .run();
+    });
+
+    it('handles error thrown from api', async () => {
+      expectSaga(logoutFlow)
+        .provide([[matchers.call.fn(api.logout), throwError(error)]])
+        .put({
+          type: LOGOUT_FAILURE,
+          error,
+        })
+        .run();
+    });
+  });
+
+  describe('watchForLogoutFlow saga', () => {
+    const generator = watchForLogoutFlow();
+    it('should call watchers functions', async () => {
+      expect(generator.next().value).toEqual(
+        takeLatest(LOGOUT_REQUEST, logoutFlow),
+      );
+    });
+  });
+});
+
+describe("fetchSchemaForEntity", () => {
+  it("handle success response from fetchSchemaForEntity", () => {
+    expectSaga(fetchSchemaForEntity, {
+      queryParams: {
+        type: 'tags'
+      },
+    })
+      .provide([
+        [
+          matchers.call.fn(api.fetchSchemaForEntity),
+          {
+            success: true,
+            response: {},
+          },
+        ],
+      ])
+      .put({
+        type: GET_SCHEMA_FOR_ENTITY_SUCCESS,
+        data: {},
+        statusCode: '',
+        entityType: 'tags'
+      })
+      .run();
+  });
+
+  it("handle success response from fetchSchemaForEntity when metaEntities available", () => {
+    expectSaga(fetchSchemaForEntity, {
+      queryParams: {
+        type: 'tags'
+      },
+    })
+      .provide([
+        [
+          matchers.call.fn(api.fetchSchemaForEntity),
+          {
+            response: {
+              metaEntities: []
+            },
+          },
+        ],
+      ])
+      .put({
+        type: GET_SCHEMA_FOR_ENTITY_SUCCESS,
+        data: {
+          metaEntities: []
+        },
+        statusCode: '',
+        entityType: 'tags'
+      })
+      .run();
+  });
+
+  it("handle when response and query params are empty from fetchSchemaForEntity when metaEntities available", () => {
+    expectSaga(fetchSchemaForEntity, {})
+      .provide([
+        [
+          matchers.call.fn(api.fetchSchemaForEntity),
+          {
+            success: true
+          },
+        ],
+      ])
+      .put({
+        type: GET_SCHEMA_FOR_ENTITY_SUCCESS,
+        data: {},
+        statusCode: '',
+        entityType: ''
+      })
+      .run();
+  });
+
+  it("handle error response from fetchSchemaForEntity", () => {
+    expectSaga(fetchSchemaForEntity, {
+      queryParams: {
+        type: 'tags'
+      },
+    })
+      .provide([
+        [
+          matchers.call.fn(api.fetchSchemaForEntity),
+          {
+            success: false,
+            response: {},
+          },
+        ],
+      ])
+      .put({
+        type: GET_SCHEMA_FOR_ENTITY_FAILURE,
+        error: 'Error in fetching tags'
+      })
+      .run();
+  });
+});
+

package/containers/Dashboard/actions.js

@@ -0,0 +1,15 @@
+/*
+ *
+ * Dashboard actions
+ *
+ */
+
+import {
+  DEFAULT_ACTION,
+} from './constants';
+
+export function defaultAction() {
+  return {
+    type: DEFAULT_ACTION,
+  };
+}

package/containers/Dashboard/constants.js

@@ -0,0 +1,7 @@
+/*
+ *
+ * Dashboard constants
+ *
+ */
+
+export const DEFAULT_ACTION = 'app/Dashboard/DEFAULT_ACTION';

package/containers/Dashboard/index.js

@@ -0,0 +1,76 @@
+import PropTypes from 'prop-types';
+import React from 'react';
+import { connect } from 'react-redux';
+import Helmet from 'react-helmet';
+import { bindActionCreators, compose } from 'redux';
+import { FormattedMessage } from 'react-intl';
+import { createStructuredSelector } from 'reselect';
+import injectSaga from 'utils/injectSaga';
+import injectReducer from 'utils/injectReducer';
+import makeSelectDashboard from './selectors';
+import makeSelectApp from '../App/selectors';
+import messages from './messages';
+import { UserIsAuthenticated } from '../../utils/authWrapper';
+import * as actions from './actions';
+import PageHeader from '../../components/PageHeader';
+import BreadCrumbs from '../../components/BreadCrumbs/index';
+import { dashboardSaga } from './sagas';
+import reducer from './reducer';
+export class Dashboard extends React.Component { // eslint-disable-line react/prefer-stateless-function
+  componentWillMount() {
+    this.props.router.push({
+      pathname: `/sms`,
+    });
+  }
+  render() {
+    return (
+      <div>
+        <FormattedMessage {...messages.header}>
+          {message => (
+            <Helmet
+              title={message}
+              meta={[
+                {
+                  name: 'description',
+                  content: <FormattedMessage {...messages.header} />,
+                },
+              ]}
+            />
+          )}
+        </FormattedMessage>
+      </div>
+    );
+  }
+}
+
+Dashboard.propTypes = {
+  router: PropTypes.object,
+};
+
+const mapStateToProps = createStructuredSelector({
+  App: makeSelectApp(),
+  Dashboard: makeSelectDashboard(),
+});
+
+
+function mapDispatchToProps(dispatch) {
+  return {
+    actions: bindActionCreators(actions, dispatch),
+  };
+}
+
+
+const withConnect = connect(
+  mapStateToProps,
+  mapDispatchToProps,
+);
+
+const withSaga = injectSaga({ key: 'dashboard', saga: dashboardSaga });
+const withReducer = injectReducer({ key: 'dashboard', reducer });
+
+export default compose(
+  UserIsAuthenticated,
+  withSaga,
+  withReducer,
+  withConnect,
+)(Dashboard);

package/containers/Dashboard/messages.js

@@ -0,0 +1,13 @@
+/*
+ * Dashboard Messages
+ *
+ * This contains all the text for the Dashboard component.
+ */
+import { defineMessages } from 'react-intl';
+
+export default defineMessages({
+  header: {
+    id: 'creatives.containers.Dashboard.header',
+    defaultMessage: 'Dashboard',
+  },
+});

package/containers/Dashboard/reducer.js

@@ -0,0 +1,21 @@
+/*
+ *
+ * Dashboard reducer
+ *
+ */
+
+import { fromJS } from 'immutable';
+import { DEFAULT_ACTION } from './constants';
+
+const initialState = fromJS({});
+
+function dashboardReducer(state = initialState, action) {
+  switch (action.type) {
+    case DEFAULT_ACTION:
+      return state;
+    default:
+      return state;
+  }
+}
+
+export default dashboardReducer;

package/containers/Dashboard/sagas.js

@@ -0,0 +1,17 @@
+import { all } from 'redux-saga/effects';
+
+// Individual exports for testing
+export function* defaultSaga() {
+  // See example in containers/HomePage/sagas.js
+}
+
+// All sagas to be loaded
+export default [
+  defaultSaga,
+];
+
+export function* dashboardSaga() {
+  yield all([
+    defaultSaga(),
+  ])
+}

package/containers/Dashboard/selectors.js

@@ -0,0 +1,25 @@
+import { createSelector } from 'reselect';
+
+/**
+ * Direct selector to the dashboard state domain
+ */
+const selectDashboardDomain = () => (state) => state.get('cap');
+
+/**
+ * Other specific selectors
+ */
+
+
+/**
+ * Default selector used by Dashboard
+ */
+
+const makeSelectDashboard = () => createSelector(
+  selectDashboardDomain(),
+  (substate) => substate.toJS()
+);
+
+export default makeSelectDashboard;
+export {
+  selectDashboardDomain,
+};

package/containers/Dashboard/test/saga.test.js

@@ -0,0 +1,9 @@
+import { expectSaga } from "redux-saga-test-plan";
+
+import { dashboardSaga } from "../sagas";
+
+describe("dashboardSaga Combined", () => {
+  test.concurrent("should initialize all dashboardSaga-related watcher sagas without error", () => {
+    return expectSaga(dashboardSaga).run();
+  });
+});

package/containers/Ebill/_ebill.scss

@@ -0,0 +1,5 @@
+.ebill-container {
+  .ant-tabs-extra-content {
+    margin-right: 24px;
+  }
+}

package/containers/Ebill/actions.js

@@ -0,0 +1,43 @@
+/*
+ *
+ * Ebill actions
+ *
+ */
+
+import * as types from './constants';
+
+export function createTemplate(template) {
+  return {
+    type: types.CREATE_TEMPLATE_REQUEST,
+    template,
+  };
+}
+
+export function getTemplateDetails(id, channel) {
+  
+  return {
+    type: types.GET_TEMPLATE_DETAILS_REQUEST,
+    id,
+    channel,
+  };
+}
+
+export function getCmsData(cmsType, projectId) {
+  return {
+    type: types.GET_CMS_EDITOR_DATA_REQUEST,
+    cmsType,
+    projectId,
+  };
+}
+
+export function clearCRUDResponse() {
+  return {
+    type: types.CLEAR_EBILL_CRUD_RESPONSE_REQUEST,
+  };
+}
+
+export function clearStoreValues() {
+  return {
+    type: types.CLEAR_ALL_VALUES,
+  };
+}

package/containers/Ebill/constants.js

@@ -0,0 +1,20 @@
+/*
+ *
+ * Ebill constants
+ *
+ */
+
+export const CREATE_TEMPLATE_REQUEST = 'app/containers/Ebill/CREATE_TEMPLATE_REQUEST';
+export const CREATE_TEMPLATE_SUCCESS = 'app/containers/Ebill/CREATE_TEMPLATE_SUCCESS';
+export const CREATE_TEMPLATE_FAILURE = 'app/containers/Ebill/CREATE_TEMPLATE_FAILURE';
+
+export const GET_TEMPLATE_DETAILS_REQUEST = 'app/containers/Ebill/GET_TEMPLATE_DETAILS_REQUEST';
+export const GET_TEMPLATE_DETAILS_SUCCESS = 'app/containers/Ebill/GET_TEMPLATE_DETAILS_SUCCESS';
+export const GET_TEMPLATE_DETAILS_FAILURE = 'app/containers/Ebill/GET_TEMPLATE_DETAILS_FAILURE';
+
+export const GET_CMS_EDITOR_DATA_REQUEST = 'app/containers/Ebill/GET_CMS_EDITOR_DATA_REQUEST';
+export const GET_CMS_EDITOR_DATA_SUCCESS = 'app/containers/Ebill/GET_CMS_EDITOR_DATA_SUCCESS';
+export const GET_CMS_EDITOR_DATA_FAILURE = 'app/containers/Ebill/GET_CMS_EDITOR_DATA_FAILURE';
+
+export const CLEAR_EBILL_CRUD_RESPONSE_REQUEST = 'app/containers/Ebill/CLEAR_EBILL_CRUD_RESPONSE_REQUEST';
+export const CLEAR_ALL_VALUES = "app/containers/Ebill/CLEAR_ALL_VALUES";