@eturnity/eturnity_reusable_components 7.39.5-qa-elisee-7.42.1 → 7.45.1-EPDM-12459.0

package/src/components/inputs/inputText/inputText.spec.js

@@ -1,588 +0,0 @@
-/* eslint-disable */
-import { mount, Wrapper } from '@vue/test-utils'
-import RCInputText from '@/components/inputs/inputText/index'
-import theme from '@/assets/theme'
-
-jest.mock('@/components/icon/iconCache.mjs', () => ({
-  // need to mock this due to how jest handles import.meta
-  fetchIcon: jest.fn(() => Promise.resolve('mocked-icon-url.svg')),
-}))
-
-const wrapper1 = mount(RCInputText, {
-  props: {
-    placeholder: 'placeholderText',
-    value: 'Test value',
-    label: 'Test label',
-  },
-  global: {
-    provide: {
-      theme,
-    },
-  },
-})
-const wrapperPassword = mount(RCInputText, {
-  props: {
-    placeholder: 'placeholderText',
-    value: 'Test value',
-    label: 'Test label',
-    inputType: 'password',
-  },
-  global: {
-    provide: {
-      theme,
-    },
-  },
-})
-describe('RCInputText.vue', () => {
-  let consoleWarnSpy
-  beforeEach(() => {
-    consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {})
-  })
-  afterEach(() => {
-    consoleWarnSpy.mockRestore()
-  })
-  // initial rendering
-  it('input is rendered', async () => {
-    const inputTextWrapper = wrapper1.find('[data-test-id="input_wrapper"]')
-    expect(inputTextWrapper.exists()).toBe(true)
-  })
-  // event management
-  it('input is rendered and emits inputChange when input event is triggered.', async () => {
-    const inputElement = wrapper1.find('input')
-    await inputElement.setValue('Test Input Value')
-    const emittedInputChangeEvent = wrapper1.emitted('input-change')
-    expect(emittedInputChangeEvent).toBeTruthy()
-    expect(emittedInputChangeEvent).toHaveLength(1) // Check if the event was emitted exactly once
-    expect(emittedInputChangeEvent[0]).toEqual(['Test Input Value'])
-  })
-  it('input emits on-enter-click', async () => {
-    const inputElement = wrapper1.find('input')
-    await inputElement.trigger('keyup.enter')
-    const emittedOnEnterClickEvent = wrapper1.emitted('on-enter-click')
-    expect(emittedOnEnterClickEvent).toBeTruthy()
-    expect(emittedOnEnterClickEvent).toHaveLength(1) // Check if the event was emitted exactly once
-    expect(emittedOnEnterClickEvent[0]).toEqual([]) // Check if the event was emitted exactly once
-  })
-  it('input emits on-blur', async () => {
-    const inputElement = wrapper1.find('input')
-    await inputElement.setValue('Test Input Value')
-    await inputElement.trigger('blur')
-    const emittedOnBlurEvent = wrapper1.emitted('input-blur')
-    expect(emittedOnBlurEvent).toBeTruthy()
-    expect(emittedOnBlurEvent).toHaveLength(1) // Check if the event was emitted exactly once
-    expect(emittedOnBlurEvent[0]).toEqual(['Test Input Value']) // Check if the event was emitted exactly once
-  })
-  it('input password visibility click trigger input type change', async () => {
-    const inputElement = wrapperPassword.find('input')
-    const passwordVisibilityIconElement = wrapperPassword.find(
-      '[data-test-id="password_visiblity_change_icon"]'
-    )
-    expect(passwordVisibilityIconElement.exists()).toBe(true)
-    await passwordVisibilityIconElement.trigger('click')
-    let inputType = inputElement.attributes().type
-    expect(inputType).toBe('text')
-    await passwordVisibilityIconElement.trigger('click')
-    inputType = inputElement.attributes().type
-    expect(inputType).toBe('password')
-    await passwordVisibilityIconElement.trigger('click')
-    inputType = inputElement.attributes().type
-    expect(inputType).toBe('text')
-  })
-  //Test conditional visibility
-  it('label visibility check', async () => {
-    const wrapper = mount(RCInputText, {
-      props: {
-        value: 'Test value',
-        label: 'Test label',
-      },
-      global: {
-        provide: {
-          theme,
-        },
-      },
-    })
-    const label = wrapper.find('[data-test-id="label_wrapper"]')
-    expect(label.exists()).toBe(true)
-    expect(label.text()).toContain('Test label')
-  })
-  it('label invisibility check', async () => {
-    const wrapper = mount(RCInputText, {
-      props: {
-        value: 'Test value',
-      },
-      global: {
-        provide: {
-          theme,
-        },
-      },
-    })
-    const label = wrapper.find('[data-test-id="label_wrapper"]')
-    expect(label.exists()).toBe(false)
-  })
-  it('label optional visibility check', async () => {
-    const wrapper = mount(RCInputText, {
-      props: {
-        value: 'Test value',
-        label: 'Test label',
-        labelOptional: true,
-      },
-      global: {
-        provide: {
-          theme,
-        },
-      },
-    })
-    const labelOptional = wrapper.find('[data-test-id="label_optional"]')
-    expect(labelOptional.exists()).toBe(true)
-  })
-  it('label optional invisibility check', async () => {
-    const wrapper = mount(RCInputText, {
-      props: {
-        value: 'Test value',
-      },
-      global: {
-        provide: {
-          theme,
-        },
-      },
-    })
-    const labelOptional = wrapper.find('[data-test-id="label_optional"]')
-    expect(labelOptional.exists()).toBe(false)
-  })
-  it('infoTextMessage visibility check', async () => {
-    const wrapper = mount(RCInputText, {
-      props: {
-        value: 'Test value',
-        infoTextMessage: 'infoTextMessage test',
-        label: 'Test label',
-      },
-      global: {
-        provide: {
-          theme,
-        },
-      },
-    })
-    const InfoTextMessage = wrapper.find('[data-test-id="info_text_message"]')
-    expect(InfoTextMessage.exists()).toBe(true)
-  })
-  it('infoTextMessage invibility check', async () => {
-    const wrapper = mount(RCInputText, {
-      props: {
-        value: 'Test value',
-        label: 'Test label',
-      },
-      global: {
-        provide: {
-          theme,
-        },
-      },
-    })
-    const InfoTextMessage = wrapper.find('[data-test-id="info_text_message"]')
-    expect(InfoTextMessage.exists()).toBe(false)
-  })
-  it('error visibility check', async () => {
-    const wrapper = mount(RCInputText, {
-      props: {
-        value: 'Test value',
-        isError: true,
-        errorMessage: 'Error message test',
-        label: 'Test label',
-      },
-      global: {
-        provide: {
-          theme,
-        },
-      },
-    })
-    const errorWrapper = wrapper.find('[data-test-id="error_wrapper"]')
-    const errorMessageWrapper = wrapper.find(
-      '[data-test-id="error_message_wrapper"]'
-    )
-    expect(errorWrapper.exists()).toBe(true)
-    expect(errorMessageWrapper.exists()).toBe(true)
-    expect(errorMessageWrapper.text()).toContain('Error message test')
-  })
-  it('error invibility check', async () => {
-    const wrapper = mount(RCInputText, {
-      props: {
-        value: 'Test value',
-        label: 'Test label',
-      },
-      global: {
-        provide: {
-          theme,
-        },
-      },
-    })
-    const errorWrapper = wrapper.find('[data-test-id="error_wrapper"]')
-    const errorMessageWrapper = wrapper.find(
-      '[data-test-id="error_message_wrapper"]'
-    )
-    expect(errorWrapper.exists()).toBe(false)
-    expect(errorMessageWrapper.exists()).toBe(false)
-  })
-  //Test that the component handles different prop types correctly and throws appropriate warnings for invalid props.
-  it('validation of prop type - placeholder - not String', async () => {
-    mount(RCInputText, {
-      props: {
-        placeholder: 42,
-        value: 'value test',
-      },
-      global: {
-        provide: {
-          theme,
-        },
-      },
-    })
-    expect(consoleWarnSpy).toHaveBeenCalled()
-  })
-  it('validation of prop type - alignItems - not horizontal or vertical', async () => {
-    mount(RCInputText, {
-      props: {
-        value: 'value test',
-        alignItems: 'top',
-      },
-      global: {
-        provide: {
-          theme,
-        },
-      },
-    })
-    expect(consoleWarnSpy).toHaveBeenCalled()
-  })
-  it('validation of prop type - isError - not Boolean', async () => {
-    mount(RCInputText, {
-      props: {
-        value: 'value test',
-        isError: 'true',
-      },
-      global: {
-        provide: {
-          theme,
-        },
-      },
-    })
-    expect(consoleWarnSpy).toHaveBeenCalled()
-  })
-  it('validation of prop type - inputWidth - not String', async () => {
-    mount(RCInputText, {
-      props: {
-        value: 'value test',
-        inputWidth: 200,
-      },
-      global: {
-        provide: {
-          theme,
-        },
-      },
-    })
-    expect(consoleWarnSpy).toHaveBeenCalled()
-  })
-  it('validation of prop type - inputHeight - not String', async () => {
-    mount(RCInputText, {
-      props: {
-        value: 'value test',
-        inputHeight: 200,
-      },
-      global: {
-        provide: {
-          theme,
-        },
-      },
-    })
-    expect(consoleWarnSpy).toHaveBeenCalled()
-  })
-  it('validation of prop type - minWidth - not String', async () => {
-    mount(RCInputText, {
-      props: {
-        value: 'value test',
-        minWidth: 200,
-      },
-      global: {
-        provide: {
-          theme,
-        },
-      },
-    })
-    expect(consoleWarnSpy).toHaveBeenCalled()
-  })
-  it('validation of prop type - value - not String', async () => {
-    mount(RCInputText, {
-      props: {
-        value: 42,
-      },
-      global: {
-        provide: {
-          theme,
-        },
-      },
-    })
-    expect(consoleWarnSpy).toHaveBeenCalled()
-  })
-  it('validation of prop type - errorMessage - not String', async () => {
-    mount(RCInputText, {
-      props: {
-        value: 'test value',
-        errorMessage: true,
-      },
-      global: {
-        provide: {
-          theme,
-        },
-      },
-    })
-    expect(consoleWarnSpy).toHaveBeenCalled()
-  })
-  it('validation of prop type - infoTextMessage - not String', async () => {
-    mount(RCInputText, {
-      props: {
-        value: 'test value',
-        infoTextMessage: true,
-      },
-      global: {
-        provide: {
-          theme,
-        },
-      },
-    })
-    expect(consoleWarnSpy).toHaveBeenCalled()
-  })
-  it('validation of prop type - infoTextAlign - not String', async () => {
-    mount(RCInputText, {
-      props: {
-        value: 'test value',
-        infoTextAlign: true,
-      },
-      global: {
-        provide: {
-          theme,
-        },
-      },
-    })
-    expect(consoleWarnSpy).toHaveBeenCalled()
-  })
-  it('validation of prop type - label - not String', async () => {
-    mount(RCInputText, {
-      props: {
-        value: 'test value',
-        label: true,
-      },
-      global: {
-        provide: {
-          theme,
-        },
-      },
-    })
-    expect(consoleWarnSpy).toHaveBeenCalled()
-  })
-  it('validation of prop type - labelOptional - not Boolean', async () => {
-    const wrapper = mount(RCInputText, {
-      props: {
-        value: 'test value',
-        labelOptional: 12,
-        label: 'label test',
-      },
-      global: {
-        provide: {
-          theme,
-        },
-      },
-    })
-    wrapper.vm.$gettext.mockReturnValue('Translated Message')
-    expect(consoleWarnSpy).toHaveBeenCalled()
-  })
-  it('validation of prop type - noBorder - not Boolean', async () => {
-    mount(RCInputText, {
-      props: {
-        value: 'test value',
-        noBorder: 1,
-      },
-      global: {
-        provide: {
-          theme,
-        },
-      },
-    })
-    expect(consoleWarnSpy).toHaveBeenCalled()
-  })
-  it('validation of prop type - disabled - not Boolean', async () => {
-    mount(RCInputText, {
-      props: {
-        disabled: 'false',
-        value: 'value test',
-      },
-      global: {
-        provide: {
-          theme,
-        },
-      },
-    })
-    expect(consoleWarnSpy).toHaveBeenCalled()
-  })
-  it('validation of prop type - fontSize - not String', async () => {
-    mount(RCInputText, {
-      props: {
-        fontSize: true,
-        value: 'value test',
-      },
-      global: {
-        provide: {
-          theme,
-        },
-      },
-    })
-    expect(consoleWarnSpy).toHaveBeenCalled()
-  })
-  it('validation of prop type - inputType - not String', async () => {
-    mount(RCInputText, {
-      props: {
-        inputType: true,
-        value: 'value test',
-      },
-      global: {
-        provide: {
-          theme,
-        },
-      },
-    })
-    expect(consoleWarnSpy).toHaveBeenCalled()
-  })
-  it('validation of prop type - labelFontColor - not String', async () => {
-    mount(RCInputText, {
-      props: {
-        labelFontColor: true,
-        value: 'value test',
-        label: 'label text',
-      },
-      global: {
-        provide: {
-          theme,
-        },
-      },
-    })
-    expect(consoleWarnSpy).toHaveBeenCalled()
-  })
-  it('validation of prop type - backgroundColor - not String', async () => {
-    mount(RCInputText, {
-      props: {
-        backgroundColor: true,
-        value: 'value test',
-      },
-      global: {
-        provide: {
-          theme,
-        },
-      },
-    })
-    expect(consoleWarnSpy).toHaveBeenCalled()
-  })
-  it('validation of prop type - disabledBackgroundColor - not String', async () => {
-    mount(RCInputText, {
-      props: {
-        disabledBackgroundColor: true,
-        value: 'value test',
-      },
-      global: {
-        provide: {
-          theme,
-        },
-      },
-    })
-    expect(consoleWarnSpy).toHaveBeenCalled()
-  })
-  it('validation of prop type - fontColor - not String', async () => {
-    mount(RCInputText, {
-      props: {
-        fontColor: true,
-        value: 'value test',
-      },
-      global: {
-        provide: {
-          theme,
-        },
-      },
-    })
-    expect(consoleWarnSpy).toHaveBeenCalled()
-  })
-  it('validation of prop type - hasFocus - not Boolean', async () => {
-    mount(RCInputText, {
-      props: {
-        hasFocus: 'true',
-        value: 'value test',
-      },
-      global: {
-        provide: {
-          theme,
-        },
-      },
-    })
-    expect(consoleWarnSpy).toHaveBeenCalled()
-  })
-  it('validation of prop type - borderColor - not String', async () => {
-    mount(RCInputText, {
-      props: {
-        borderColor: 42,
-        value: 'value test',
-      },
-      global: {
-        provide: {
-          theme,
-        },
-      },
-    })
-    expect(consoleWarnSpy).toHaveBeenCalled()
-  })
-  it('validation of prop type - labelDataId - not String', async () => {
-    mount(RCInputText, {
-      props: {
-        labelDataId: 42,
-        value: 'value test',
-      },
-      global: {
-        provide: {
-          theme,
-        },
-      },
-    })
-    expect(consoleWarnSpy).toHaveBeenCalled()
-  })
-  it('validation of prop type - inputDataId - not String', async () => {
-    mount(RCInputText, {
-      props: {
-        inputDataId: 42,
-        value: 'value test',
-      },
-      global: {
-        provide: {
-          theme,
-        },
-      },
-    })
-    expect(consoleWarnSpy).toHaveBeenCalled()
-  })
-  //Prop Updates: Verify that the component updates correctly when props change, reflecting new values in the rendered output.
-  it('update of prop hasFocus', async () => {
-    const wrapper = mount(RCInputText, {
-      props: {
-        value: 'value test',
-        hasFocus: false,
-      },
-      global: {
-        provide: {
-          theme,
-        },
-      },
-    })
-    const inputElement = wrapper.find('input').element
-    jest.spyOn(inputElement, 'focus').mockImplementation(() => {
-      // Simulate that the input element is now the focused element
-      Object.defineProperty(document, 'activeElement', {
-        value: inputElement,
-        configurable: true,
-      })
-    })
-    await wrapper.setProps({ hasFocus: true })
-    await wrapper.vm.$nextTick()
-    expect(document.activeElement).toBe(wrapper.find('input').element)
-  })
-})

package/src/components/roundTabs/index.vue

@@ -1,107 +0,0 @@
-<template>
-  <ContainerComponent>
-    <RoundedTabLeft
-      :background-color="backgroundColor"
-      :border-radius="borderRadius"
-    />
-    <TabComponent
-      :background-color="backgroundColor"
-      :border-radius="borderRadius"
-      :height="height"
-      :width="width"
-    >
-      <slot></slot>
-    </TabComponent>
-    <RoundedTabRight
-      :background-color="backgroundColor"
-      :border-radius="borderRadius"
-    />
-  </ContainerComponent>
-</template>
-<script>
-  import styled from 'vue3-styled-components'
-
-  const ContainerComponent = styled.div`
-    position: relative;
-    display: flex;
-    align-items: center;
-    justify-content: center;
-  `
-  const RoundedTabLeft = styled('div', {
-    backgroundColor: String,
-    borderRadius: String,
-  })`
-    position:absolute;
-    bottom:0;
-    left:-${(prop) => prop.borderRadius}
-    background-color: ${(prop) => prop.backgroundColor};
-    width: ${(prop) => prop.borderRadius};
-    height: ${(prop) => prop.borderRadius};
-    -webkit-mask-image: radial-gradient(
-      circle at top left,
-      transparent 71%,
-      black 71%
-    );
-  `
-  const RoundedTabRight = styled('div', {
-    backgroundColor: String,
-    borderRadius: String,
-  })`
-  position:absolute;
-  bottom:0;
-    right:-${(prop) => prop.borderRadius}
-    background-color: ${(prop) => prop.backgroundColor};
-    width: ${(prop) => prop.borderRadius};
-    height: ${(prop) => prop.borderRadius};
-    -webkit-mask-image: radial-gradient(
-      circle at top right,
-      transparent 71%,
-      black 71%
-    );`
-  const TabComponent = styled('div', {
-    width: String,
-    height: String,
-    backgroundColor: String,
-    borderRadius: String,
-  })`
-    display: flex;
-    align-items: center;
-    justify-content: center;
-    background-color: ${(prop) => prop.backgroundColor};
-    width: ${(prop) => prop.width};
-    height: ${(prop) => prop.height};
-    border-radius: ${(prop) => prop.borderRadius} ${(prop) => prop.borderRadius}
-      0 0;
-  `
-  export default {
-    name: 'RoundTabs',
-    components: {
-      ContainerComponent,
-      TabComponent,
-      RoundedTabLeft,
-      RoundedTabRight,
-    },
-    props: {
-      height: {
-        required: false,
-        default: '40px',
-        type: String,
-      },
-      width: {
-        required: false,
-        default: '200px',
-        type: String,
-      },
-      backgroundColor: {
-        required: false,
-        default: 'white',
-        type: String,
-      },
-      borderRadius: {
-        required: false,
-        default: '20px',
-        type: String,
-      },
-    },
-  }
-</script>