react-native-ui-lib 8.0.1 → 8.1.0

package/src/incubator/calendar/__tests__/DateUtils.spec.js

@@ -0,0 +1,367 @@
+import * as DateUtils from "../helpers/DateUtils";
+import { FirstDayOfWeek, DayNamesFormat } from "../types";
+describe('Calendar/DateUtils', () => {
+  describe('getWeekNumbersOfMonth', () => {
+    it('should return week numbers of first month in a year', () => {
+      let weekNumbers = DateUtils.getWeekNumbersOfMonth(2023, 0, FirstDayOfWeek.MONDAY);
+      expect(weekNumbers).toEqual([1, 2, 3, 4, 5, 6]);
+      weekNumbers = DateUtils.getWeekNumbersOfMonth(2023, 0, FirstDayOfWeek.SUNDAY);
+      expect(weekNumbers).toEqual([1, 2, 3, 4, 5]);
+      weekNumbers = DateUtils.getWeekNumbersOfMonth(2022, 0, FirstDayOfWeek.MONDAY);
+      expect(weekNumbers).toEqual([1, 2, 3, 4, 5, 6]);
+      weekNumbers = DateUtils.getWeekNumbersOfMonth(2022, 0, FirstDayOfWeek.SUNDAY);
+      expect(weekNumbers).toEqual([1, 2, 3, 4, 5, 6]);
+      weekNumbers = DateUtils.getWeekNumbersOfMonth(2018, 0, FirstDayOfWeek.MONDAY);
+      expect(weekNumbers).toEqual([1, 2, 3, 4, 5]);
+      weekNumbers = DateUtils.getWeekNumbersOfMonth(2018, 0, FirstDayOfWeek.SUNDAY);
+      expect(weekNumbers).toEqual([1, 2, 3, 4, 5]);
+    });
+    it('should return week numbers of last month in a year', () => {
+      let weekNumbers = DateUtils.getWeekNumbersOfMonth(2022, 11, FirstDayOfWeek.MONDAY);
+      expect(weekNumbers).toEqual([49, 50, 51, 52, 53]);
+      weekNumbers = DateUtils.getWeekNumbersOfMonth(2018, 11, FirstDayOfWeek.MONDAY);
+      expect(weekNumbers).toEqual([48, 49, 50, 51, 52, 53]);
+    });
+    it('should return week numbers of a month with 6 weeks', () => {
+      let weekNumbers = DateUtils.getWeekNumbersOfMonth(2018, 3, FirstDayOfWeek.MONDAY);
+      expect(weekNumbers).toEqual([13, 14, 15, 16, 17, 18]);
+      weekNumbers = DateUtils.getWeekNumbersOfMonth(2018, 8, FirstDayOfWeek.SUNDAY);
+      expect(weekNumbers).toEqual([35, 36, 37, 38, 39, 40]);
+    });
+    it('should throw error when passing invalid month', () => {
+      expect(() => DateUtils.getWeekNumbersOfMonth(2022, 12, FirstDayOfWeek.MONDAY)).toThrowError('getWeekNumbersOfMonth util received an invalid month');
+    });
+  });
+  describe('getFirstDayInTheYear', () => {
+    describe('2020', () => {
+      it('2020 When Saturday is first day of the week - should return Saturday Dec 28th', () => {
+        const firstDayInTheYear = DateUtils._forTesting.getFirstDayInTheYear(2020, FirstDayOfWeek.SATURDAY);
+        const dayObject = DateUtils.getDateObject(firstDayInTheYear);
+        expect(dayObject.day).toBe(28);
+        expect(dayObject.month).toBe(11);
+        expect(dayObject.dayOfTheWeek).toBe(6);
+      });
+      it('2020 When Sunday is first day of the week - should return Sunday Dec 29th', () => {
+        const firstDayInTheYear = DateUtils._forTesting.getFirstDayInTheYear(2020, FirstDayOfWeek.SUNDAY);
+        const dayObject = DateUtils.getDateObject(firstDayInTheYear);
+        expect(dayObject.day).toBe(29);
+        expect(dayObject.month).toBe(11);
+        expect(dayObject.dayOfTheWeek).toBe(0);
+      });
+      it('2020 When Monday is first day of the week - should return Monday Dec 30th', () => {
+        const firstDayInTheYear = DateUtils._forTesting.getFirstDayInTheYear(2020, FirstDayOfWeek.MONDAY);
+        const dayObject = DateUtils.getDateObject(firstDayInTheYear);
+        expect(dayObject.day).toBe(30);
+        expect(dayObject.month).toBe(11);
+        expect(dayObject.dayOfTheWeek).toBe(1);
+      });
+    });
+    describe('2021', () => {
+      it('2021 When Saturday is first day of the week - should return Saturday Dec 26th', () => {
+        const firstDayInTheYear = DateUtils._forTesting.getFirstDayInTheYear(2021, FirstDayOfWeek.SATURDAY);
+        const dayObject = DateUtils.getDateObject(firstDayInTheYear);
+        expect(dayObject.day).toBe(26);
+        expect(dayObject.month).toBe(11);
+        expect(dayObject.dayOfTheWeek).toBe(6);
+      });
+      it('2021 When Sunday is first day of the week - should return Sunday Dec 27th', () => {
+        const firstDayInTheYear = DateUtils._forTesting.getFirstDayInTheYear(2021, FirstDayOfWeek.SUNDAY);
+        const dayObject = DateUtils.getDateObject(firstDayInTheYear);
+        expect(dayObject.day).toBe(27);
+        expect(dayObject.month).toBe(11);
+        expect(dayObject.dayOfTheWeek).toBe(0);
+      });
+      it('2021 When Monday is first day of the week - should return Monday Dec 28th', () => {
+        const firstDayInTheYear = DateUtils._forTesting.getFirstDayInTheYear(2021, FirstDayOfWeek.MONDAY);
+        const dayObject = DateUtils.getDateObject(firstDayInTheYear);
+        expect(dayObject.day).toBe(28);
+        expect(dayObject.month).toBe(11);
+        expect(dayObject.dayOfTheWeek).toBe(1);
+      });
+    });
+    describe('2022', () => {
+      it('2022 When Saturday is first day of the week - should return Saturday Jan 1st', () => {
+        const firstDayInTheYear = DateUtils._forTesting.getFirstDayInTheYear(2022, FirstDayOfWeek.SATURDAY);
+        const dayObject = DateUtils.getDateObject(firstDayInTheYear);
+        expect(dayObject.day).toBe(1);
+        expect(dayObject.month).toBe(0);
+        expect(dayObject.dayOfTheWeek).toBe(6);
+      });
+      it('2022 When Sunday is first day of the week - should return Sunday Dec 26th', () => {
+        const firstDayInTheYear = DateUtils._forTesting.getFirstDayInTheYear(2022, FirstDayOfWeek.SUNDAY);
+        const dayObject = DateUtils.getDateObject(firstDayInTheYear);
+        expect(dayObject.day).toBe(26);
+        expect(dayObject.month).toBe(11);
+        expect(dayObject.dayOfTheWeek).toBe(0);
+      });
+      it('2022 When Monday is first day of the week - should return Monday Dec 27th', () => {
+        const firstDayInTheYear = DateUtils._forTesting.getFirstDayInTheYear(2022, FirstDayOfWeek.MONDAY);
+        const dayObject = DateUtils.getDateObject(firstDayInTheYear);
+        expect(dayObject.day).toBe(27);
+        expect(dayObject.month).toBe(11);
+        expect(dayObject.dayOfTheWeek).toBe(1);
+      });
+    });
+    describe('2023', () => {
+      it('2023 When Saturday is first day of the week - should return Saturday Dec 31st', () => {
+        const firstDayInTheYear = DateUtils._forTesting.getFirstDayInTheYear(2023, FirstDayOfWeek.SATURDAY);
+        const dayObject = DateUtils.getDateObject(firstDayInTheYear);
+        expect(dayObject.day).toBe(31);
+        expect(dayObject.month).toBe(11);
+        expect(dayObject.dayOfTheWeek).toBe(6);
+      });
+      it('2023 When Sunday is first day of the week - should return Sunday Jan 1st', () => {
+        const firstDayInTheYear = DateUtils._forTesting.getFirstDayInTheYear(2023, FirstDayOfWeek.SUNDAY);
+        const dayObject = DateUtils.getDateObject(firstDayInTheYear);
+        expect(dayObject.day).toBe(1);
+        expect(dayObject.month).toBe(0);
+        expect(dayObject.dayOfTheWeek).toBe(0);
+      });
+      it('2023 When Monday is first day of the week - should return Monday Dec 26th', () => {
+        const firstDayInTheYear = DateUtils._forTesting.getFirstDayInTheYear(2023, FirstDayOfWeek.MONDAY);
+        const dayObject = DateUtils.getDateObject(firstDayInTheYear);
+        expect(dayObject.day).toBe(26);
+        expect(dayObject.month).toBe(11);
+        expect(dayObject.dayOfTheWeek).toBe(1);
+      });
+    });
+  });
+  describe('getDaysOfWeekNumber', () => {
+    it('should return array of 7 items', () => {
+      const daysInWeek = DateUtils.getDaysOfWeekNumber(2022, 11, FirstDayOfWeek.MONDAY);
+      expect(daysInWeek.length).toBe(7);
+    });
+    it('should return the right days at the first week of year - FirstDayOfWeek.SUNDAY', () => {
+      const daysInWeek = DateUtils.getDaysOfWeekNumber(2023, 1, FirstDayOfWeek.SUNDAY);
+      const firstDay = daysInWeek[0];
+      const lastDay = daysInWeek[6];
+      const firstDayObject = DateUtils.getDateObject(firstDay);
+      expect(firstDayObject.day).toBe(1);
+      expect(firstDayObject.month).toBe(0);
+      expect(firstDayObject.year).toBe(2023);
+      const lastDayObject = DateUtils.getDateObject(lastDay);
+      expect(lastDayObject.day).toBe(7);
+      expect(lastDayObject.month).toBe(0);
+      expect(lastDayObject.year).toBe(2023);
+    });
+
+    // TODO: We need to fix this test
+    it('should return the right days at the first week of year - FirstDayOfWeek.MONDAY', () => {
+      const daysInWeek = DateUtils.getDaysOfWeekNumber(2023, 1, FirstDayOfWeek.MONDAY);
+      const firstDay = daysInWeek[0];
+      const lastDay = daysInWeek[6];
+      const firstDayObject = DateUtils.getDateObject(firstDay);
+      expect(firstDayObject.day).toBe(26);
+      expect(firstDayObject.month).toBe(11);
+      expect(firstDayObject.year).toBe(2022);
+      const lastDayObject = DateUtils.getDateObject(lastDay);
+      expect(lastDayObject.day).toBe(1);
+      expect(lastDayObject.month).toBe(0);
+      expect(lastDayObject.year).toBe(2023);
+    });
+  });
+  describe('addMonths', () => {
+    it('should return the date timestamp for the next (1) months in the next (1) years', () => {
+      const date = DateUtils.addMonths(new Date(2022, 11, 26).getTime(), 1);
+      const dayObject = DateUtils.getDateObject(date);
+      expect(dayObject.day).toBe(26);
+      expect(dayObject.month).toBe(0);
+      expect(dayObject.year).toBe(2023);
+    });
+    it('should return the date timestamp for the next (5) months in the same year', () => {
+      const date = DateUtils.addMonths(new Date(2023, 0, 26).getTime(), 5);
+      const dayObject = DateUtils.getDateObject(date);
+      expect(dayObject.day).toBe(26);
+      expect(dayObject.month).toBe(5);
+      expect(dayObject.year).toBe(2023);
+    });
+    it('should return the date timestamp for the next (13) months in the next (2) years', () => {
+      const date = DateUtils.addMonths(new Date(2022, 11, 26).getTime(), 13);
+      const dayObject = DateUtils.getDateObject(date);
+      expect(dayObject.day).toBe(26);
+      expect(dayObject.month).toBe(0);
+      expect(dayObject.year).toBe(2024);
+    });
+    it('should return the date timestamp for the next (24) months in the next (2) years', () => {
+      const date = DateUtils.addMonths(new Date(2022, 11, 26).getTime(), 24);
+      const dayObject = DateUtils.getDateObject(date);
+      expect(dayObject.day).toBe(26);
+      expect(dayObject.month).toBe(11);
+      expect(dayObject.year).toBe(2024);
+    });
+
+    // subtract
+    it('should return the date timestamp for the previous (-1) months in the previous (1) years', () => {
+      const date = DateUtils.addMonths(new Date(2023, 0, 26).getTime(), -1);
+      const dayObject = DateUtils.getDateObject(date);
+      expect(dayObject.day).toBe(26);
+      expect(dayObject.month).toBe(11);
+      expect(dayObject.year).toBe(2022);
+    });
+    it('should return the date timestamp for the previous (-5) months in the same year', () => {
+      const date = DateUtils.addMonths(new Date(2022, 11, 26).getTime(), -5);
+      const dayObject = DateUtils.getDateObject(date);
+      expect(dayObject.day).toBe(26);
+      expect(dayObject.month).toBe(6);
+      expect(dayObject.year).toBe(2022);
+    });
+    it('should return the date timestamp for the previous (-13) months in the previous (2) years', () => {
+      const date = DateUtils.addMonths(new Date(2022, 11, 26).getTime(), -13);
+      const dayObject = DateUtils.getDateObject(date);
+      expect(dayObject.day).toBe(26);
+      expect(dayObject.month).toBe(10);
+      expect(dayObject.year).toBe(2021);
+    });
+    it('should return the date timestamp for the previous (-24) months in the previous (2) years', () => {
+      const date = DateUtils.addMonths(new Date(2022, 11, 26).getTime(), -24);
+      const dayObject = DateUtils.getDateObject(date);
+      expect(dayObject.day).toBe(26);
+      expect(dayObject.month).toBe(11);
+      expect(dayObject.year).toBe(2020);
+    });
+
+    // useFirstDay
+    it('should return the date timestamp for the 1st day of the next (1) months in the next (1) years', () => {
+      const date = DateUtils.addMonths(new Date(2022, 11, 26).getTime(), 1, true);
+      const dayObject = DateUtils.getDateObject(date);
+      expect(dayObject.day).toBe(1);
+      expect(dayObject.month).toBe(0);
+      expect(dayObject.year).toBe(2023);
+    });
+  });
+  describe('addYears', () => {
+    it('should return the date timestamp for the next (1) year in the same month', () => {
+      const date = DateUtils.addYears(new Date(2022, 11, 26).getTime(), 1);
+      const dayObject = DateUtils.getDateObject(date);
+      expect(dayObject.day).toBe(26);
+      expect(dayObject.month).toBe(11);
+      expect(dayObject.year).toBe(2023);
+    });
+    it('should return the date timestamp for the previous (-1) year in the same month', () => {
+      const date = DateUtils.addYears(new Date(2022, 11, 26).getTime(), -1);
+      const dayObject = DateUtils.getDateObject(date);
+      expect(dayObject.day).toBe(26);
+      expect(dayObject.month).toBe(11);
+      expect(dayObject.year).toBe(2021);
+    });
+  });
+  describe('getWeekDayNames', () => {
+    it('should return the week days names for first day = Sunday', () => {
+      const weekDaysNames = DateUtils.getWeekDayNames();
+      expect(weekDaysNames[0]).toBe('Sunday');
+    });
+    it('should return the week days names for first day = Monday', () => {
+      const weekDaysNames = DateUtils.getWeekDayNames(FirstDayOfWeek.MONDAY);
+      expect(weekDaysNames[0]).toBe('Monday');
+    });
+    it('should return the week days names for first day = Saturday', () => {
+      const weekDaysNames = DateUtils.getWeekDayNames(FirstDayOfWeek.SATURDAY);
+      expect(weekDaysNames[0]).toBe('Saturday');
+    });
+    it('should return the week days names for long abbreviation format', () => {
+      const weekDaysNames = DateUtils.getWeekDayNames(FirstDayOfWeek.SUNDAY, DayNamesFormat.LONG_ABBREVIATION);
+      expect(weekDaysNames[0]).toBe('Sun');
+    });
+    it('should return the week days names for first day = Sunday', () => {
+      const weekDaysNames = DateUtils.getWeekDayNames(FirstDayOfWeek.SUNDAY, DayNamesFormat.SHORT_ABBREVIATION);
+      expect(weekDaysNames[0]).toBe('S');
+    });
+  });
+  describe('isPastDate', () => {
+    it('should return true for a past date', () => {
+      expect(DateUtils.isPastDate(new Date('2022-12-26').getTime())).toBe(true);
+    });
+    it('should return false for a future date', () => {
+      expect(DateUtils.isPastDate(new Date('2222-12-26').getTime())).toBe(false);
+    });
+  });
+  describe('isSameDay', () => {
+    it('should return true for same dates using Date objects', () => {
+      expect(DateUtils.isSameDay(new Date().getTime(), Date.now())).toBe(true);
+    });
+    it('should return true for same dates using timestamps', () => {
+      expect(DateUtils.isSameDay(1673442316000, 1673463916000)).toBe(true);
+    });
+    it('should return false for different dates using Date objects', () => {
+      expect(DateUtils.isSameDay(new Date('2022-12-26').getTime(), new Date('2022-12-27').getTime())).toBe(false);
+    });
+    it('should return false for different dates using timestamps', () => {
+      expect(DateUtils.isSameDay(1673442316000, 1674327916)).toBe(false);
+    });
+  });
+  describe('isSameMonth', () => {
+    it('should return true for same months using Date objects', () => {
+      expect(DateUtils.isSameMonth(new Date().getTime(), Date.now())).toBe(true);
+    });
+    it('should return true for same months using timestamps', () => {
+      expect(DateUtils.isSameMonth(1673950085000, 1674122885000)).toBe(true);
+    });
+    it('should return false for different months using Date objects', () => {
+      expect(DateUtils.isSameMonth(new Date('2023-12-27').getTime(), new Date('2023-11-27').getTime())).toBe(false);
+    });
+    it('should return false for different years using Date objects', () => {
+      expect(DateUtils.isSameMonth(new Date('2023-12-27').getTime(), new Date('2022-12-27').getTime())).toBe(false);
+    });
+    it('should return false for different months using timestamps', () => {
+      expect(DateUtils.isSameMonth(1673949947000, 1676628347000)).toBe(false);
+    });
+    it('should return true for different years using timestamps', () => {
+      expect(DateUtils.isSameMonth(1673949947000, 1705485947000)).toBe(false);
+    });
+    it('should return false for same month in MonthProps date format', () => {
+      expect(DateUtils.isSameMonth({
+        month: 11,
+        year: 2026,
+        timestamp: new Date(2026, 11, 1).getTime()
+      }, {
+        month: 10,
+        year: 2026,
+        timestamp: new Date(2026, 10, 1).getTime()
+      })).toBe(false);
+    });
+    it('should return false for same month in MonthProps date format', () => {
+      expect(DateUtils.isSameMonth({
+        month: 10,
+        year: 2023,
+        timestamp: new Date(2023, 10, 1).getTime()
+      }, {
+        month: 10,
+        year: 2026,
+        timestamp: new Date(2026, 10, 1).getTime()
+      })).toBe(false);
+    });
+    it('should return true for same month in MonthProps date format', () => {
+      expect(DateUtils.isSameMonth({
+        month: 10,
+        year: 2026,
+        timestamp: new Date(2026, 10, 1).getTime()
+      }, {
+        month: 10,
+        year: 2026,
+        timestamp: new Date(2026, 10, 1).getTime()
+      })).toBe(true);
+    });
+    it('should return true for same month in different date format', () => {
+      expect(DateUtils.isSameMonth({
+        month: 0,
+        year: 2022,
+        timestamp: new Date(2022, 0, 1).getTime()
+      }, new Date('2022-01-27').getTime())).toBe(true);
+    });
+    it('should return true for same month in different date format', () => {
+      expect(DateUtils.isSameMonth(new Date('2026-11-27').getTime(), {
+        month: 10,
+        year: 2026,
+        timestamp: new Date(2026, 10, 1).getTime()
+      })).toBe(true);
+    });
+  });
+  describe('getMonthForIndex', () => {
+    it('should return January for index 0 ', () => {
+      expect(DateUtils.getMonthForIndex(0)).toBe('January');
+    });
+    it('should return December for index 11 ', () => {
+      expect(DateUtils.getMonthForIndex(11)).toBe('December');
+    });
+  });
+});

package/src/incubator/expandableOverlay/__tests__/index.spec.js

@@ -0,0 +1,114 @@
+import React from 'react';
+import { render } from '@testing-library/react-native';
+import ExpandableOverlay from "../index";
+import View from "../../../components/view";
+import Text from "../../../components/text";
+import { ExpandableOverlayDriver } from "../ExpandableOverlay.driver";
+
+// What we want to test:
+/**
+ * 1. Sanity - it renders.
+ * 2. Clicking opens the modal/dialog.
+ */
+
+const testID = 'expandableOverylayTest';
+const helloWorld = 'Hello World';
+const universe = 'Hello Universe';
+const TestCase = props => {
+  return <ExpandableOverlay expandableContent={<Text>{universe}</Text>} {...props} testID={testID}>
+      <View>
+        <Text>{helloWorld}</Text>
+      </View>
+    </ExpandableOverlay>;
+};
+const getDriver = props => {
+  const renderTree = render(<TestCase {...props} />);
+  const driver = ExpandableOverlayDriver({
+    renderTree,
+    testID
+  }, props.useDialog ?? false);
+  return {
+    driver,
+    renderTree
+  };
+};
+describe('ExpandableOverlay', () => {
+  describe('With Dialog (useDialog)', () => {
+    it('Sanity', () => {
+      const {
+        driver
+      } = getDriver({
+        useDialog: true
+      });
+      expect(driver.exists()).toBeFalsy();
+    });
+    it('Test open', () => {
+      const {
+        driver
+      } = getDriver({
+        useDialog: true
+      });
+      expect(driver.isOpen()).toBeFalsy();
+      driver.open();
+      expect(driver.isOpen()).toBeTruthy();
+    });
+    it('Test pressOnBackground', () => {
+      const {
+        driver
+      } = getDriver({
+        useDialog: true
+      });
+      driver.open();
+      expect(driver.isOpen()).toBeTruthy();
+      driver.pressOnBackground();
+      expect(driver.isOpen()).toBeFalsy();
+    });
+    it(`should render ${helloWorld} on starting view and ${universe} in the dialog only after pressing`, () => {
+      const {
+        driver,
+        renderTree
+      } = getDriver({
+        useDialog: true
+      });
+      expect(renderTree.queryByText(helloWorld)).toBeTruthy();
+      expect(renderTree.queryByText(universe)).toBeFalsy();
+      driver.open();
+      expect(renderTree.queryByText(universe)).toBeTruthy();
+    });
+  });
+  describe('With Modal', () => {
+    it('Sanity', () => {
+      const {
+        driver
+      } = getDriver({});
+      expect(driver.exists()).toBeFalsy();
+    });
+    it('Test open', () => {
+      const {
+        driver
+      } = getDriver({});
+      expect(driver.isOpen()).toBeFalsy();
+      driver.open();
+      expect(driver.isOpen()).toBeTruthy();
+    });
+    it('Test pressOnBackground', () => {
+      const {
+        driver
+      } = getDriver({});
+      driver.open();
+      expect(driver.isOpen()).toBeTruthy();
+      driver.pressOnBackground();
+      expect(driver.isOpen()).toBeFalsy();
+    });
+    it(`should render ${helloWorld} on starting view and ${universe} in the dialog only after pressing`, () => {
+      const {
+        driver,
+        renderTree
+      } = getDriver({});
+      expect(renderTree.queryByText(helloWorld)).toBeTruthy();
+      expect(renderTree.queryByText(universe)).toBeFalsy();
+      driver.open();
+      expect(renderTree.queryByText(universe)).toBeTruthy();
+    });
+  });
+});

package/src/incubator/gradient/__tests__/useAngleTransform.spec.js

@@ -0,0 +1,126 @@
+import { _forTesting } from "../useAngleTransform";
+const {
+  getStartEndFromAngle
+} = _forTesting;
+describe('useAngleTransform', () => {
+  it('getStartEndFromAngle - default', () => {
+    expect(getStartEndFromAngle()).toEqual({
+      start: {
+        x: 0.5,
+        y: 1.0
+      },
+      end: {
+        x: 0.5,
+        y: 0.0
+      }
+    });
+  });
+  it('getStartEndFromAngle - 0', () => {
+    expect(getStartEndFromAngle(0)).toEqual({
+      start: {
+        x: 0.5,
+        y: 1.0
+      },
+      end: {
+        x: 0.5,
+        y: 0.0
+      }
+    });
+  });
+  it('getStartEndFromAngle - 45', () => {
+    expect(getStartEndFromAngle(45)).toEqual({
+      start: {
+        x: 0.0,
+        y: 1.0
+      },
+      end: {
+        x: 1.0,
+        y: 0.0
+      }
+    });
+  });
+  it('getStartEndFromAngle - 90', () => {
+    expect(getStartEndFromAngle(90)).toEqual({
+      start: {
+        x: 0.0,
+        y: 0.5
+      },
+      end: {
+        x: 1.0,
+        y: 0.5
+      }
+    });
+  });
+  it('getStartEndFromAngle - 135', () => {
+    expect(getStartEndFromAngle(135)).toEqual({
+      start: {
+        x: 0.0,
+        y: 0.0
+      },
+      end: {
+        x: 1.0,
+        y: 1.0
+      }
+    });
+  });
+  it('getStartEndFromAngle - 180', () => {
+    expect(getStartEndFromAngle(180)).toEqual({
+      start: {
+        x: 0.5,
+        y: 0.0
+      },
+      end: {
+        x: 0.5,
+        y: 1.0
+      }
+    });
+  });
+  it('getStartEndFromAngle - 225', () => {
+    expect(getStartEndFromAngle(225)).toEqual({
+      start: {
+        x: 1.0,
+        y: 0.0
+      },
+      end: {
+        x: 0.0,
+        y: 1.0
+      }
+    });
+  });
+  it('getStartEndFromAngle - 270', () => {
+    expect(getStartEndFromAngle(270)).toEqual({
+      start: {
+        x: 1.0,
+        y: 0.5
+      },
+      end: {
+        x: 0.0,
+        y: 0.5
+      }
+    });
+  });
+  it('getStartEndFromAngle - 315', () => {
+    expect(getStartEndFromAngle(315)).toEqual({
+      start: {
+        x: 1.0,
+        y: 1.0
+      },
+      end: {
+        x: 0.0,
+        y: 0.0
+      }
+    });
+  });
+  it('getStartEndFromAngle - 360', () => {
+    expect(getStartEndFromAngle(360)).toEqual({
+      start: {
+        x: 0.5,
+        y: 1.0
+      },
+      end: {
+        x: 0.5,
+        y: 0.0
+      }
+    });
+  });
+});

package/src/incubator/slider/__tests__/SliderPresenter.spec.js

@@ -0,0 +1,43 @@
+import * as uut from "../SliderPresenter";
+const trackWidth = 350;
+const minimum = 0;
+const maximum = 100;
+describe('Slider:Presenter', () => {
+  describe('getOffsetForValue', () => {
+    it('should return 0 for 0', () => {
+      expect(uut.getOffsetForValue(0, trackWidth)).toEqual(0);
+    });
+    it('should return 350 for 1', () => {
+      expect(uut.getOffsetForValue(1, trackWidth)).toEqual(350);
+    });
+    it('should return 175 for 0.5', () => {
+      expect(uut.getOffsetForValue(0.5, trackWidth)).toEqual(175);
+    });
+    it('should return 175 for 50, when minimumValue = 0 and maximumValue = 100', () => {
+      expect(uut.getOffsetForValue(50, trackWidth, minimum, maximum)).toEqual(175);
+    });
+    it('should return 175 for 60, when minimumValue = 20 and maximumValue = 100', () => {
+      expect(uut.getOffsetForValue(60, trackWidth, 20, maximum)).toEqual(175);
+    });
+    it('should return 175 for 60, when minimumValue = 0 and maximumValue = 80', () => {
+      expect(uut.getOffsetForValue(40, trackWidth, minimum, 80)).toEqual(175);
+    });
+  });
+  describe('getValueForOffset', () => {
+    it('should return 0 for 0', () => {
+      expect(uut.getValueForOffset(0, trackWidth)).toEqual(0);
+    });
+    it('should return 1 for 350', () => {
+      expect(uut.getValueForOffset(350, trackWidth)).toEqual(1);
+    });
+    it('should return 0.5 for 175', () => {
+      expect(uut.getValueForOffset(175, trackWidth)).toEqual(0.5);
+    });
+    it('should return 50 for 175, when minimumValue = 0 and maximumValue = 100', () => {
+      expect(uut.getValueForOffset(175, trackWidth, minimum, maximum)).toEqual(50);
+    });
+    it('should return 60 for 175, when minimumValue = 0 and maximumValue = 100 and step = 20', () => {
+      expect(uut.getValueForOffset(175, trackWidth, minimum, maximum, 20)).toEqual(60);
+    });
+  });
+});

package/src/incubator/slider/__tests__/index.spec.js

@@ -0,0 +1,34 @@
+import React from 'react';
+import Slider from "../index";
+import { SliderDriver } from "../Slider.driver";
+describe('Slider', () => {
+  afterEach(() => {
+    SliderDriver.clear();
+  });
+  const sliderDriver = (testID, props) => {
+    const defaultProps = {
+      testID,
+      onValueChange: jest.fn(),
+      disabled: false
+    };
+    const component = <Slider {...defaultProps} {...props} />;
+    return new SliderDriver({
+      component,
+      testID
+    });
+  };
+  it('Should be disabled', async () => {
+    const testId = 'slider-comp';
+    const driver = await sliderDriver(testId, {
+      disabled: true
+    });
+    expect(await driver.isDisabled()).toBe(true);
+  });
+  it('Should be disabled', async () => {
+    const testId = 'slider-comp';
+    const driver = await sliderDriver(testId, {
+      disabled: false
+    });
+    expect(await driver.isDisabled()).toBe(false);
+  });
+});