@dtable/utility/test/date-filter.spec.ts

DTable utility

import { testDateFilter, DateFilterMode, DateRange } from "../src/Filter/filter-v2/date";
import { FilterOperator } from "../src/Filter/filter-v2";
import dayjs from "dayjs";
import { utcToZonedTime } from "date-fns-tz";
import { startOfDay, addMinutes, format } from "date-fns";

describe("dataTest", () => {
  const currentData = addMinutes(startOfDay(utcToZonedTime(new Date(), 'Asia/Shanghai')), 1);
  const dateRange: DateRange = ["2022-07-02", "2022-07-13"];
  const todayISOStr = currentData.toISOString();

  /**
   * 获取相对今天的前后日期
   * @param day
   */
  function getRelativeDate(day: number): string {
    const today = currentData;
    today.setDate(today.getDate() + day)
    return today.toISOString();
  }

  it('start of day for timezone', () => {
    console.log(currentData);
  })

  describe("IsEmpty", () => {
    it("IsEmpty", () => {
      expect(testDateFilter(null, FilterOperator.IsEmpty, {})).toEqual(true);
    });
  });
  describe("IsNotEmpty", () => {
    it("IsNotEmpty", () => {
      expect(testDateFilter(todayISOStr, FilterOperator.IsNotEmpty, {})).toEqual(true);
    });
  });
  describe("Is", () => {
    it("exactDate", () => {
      const todayStr = format(currentData, 'yyyy-MM-dd');

      expect(
          testDateFilter(todayISOStr, FilterOperator.Is, {
            mode: DateFilterMode.exactDate,
            data: todayStr,
          })
      ).toEqual(true);
    });
    it("IsWithin", () => {
      expect(
          testDateFilter(dateRange[0], FilterOperator.Is, {
            mode: DateFilterMode.DateRange,
            data: dateRange,
          })
      ).toEqual(true);
      expect(
          testDateFilter(dateRange[1], FilterOperator.Is, {
            mode: DateFilterMode.DateRange,
            data: dateRange,
          })
      ).toEqual(true);
    });
    it("yesterday", () => {
      expect(
          testDateFilter(getRelativeDate(-1), FilterOperator.Is, {mode: DateFilterMode.yesterday})
      ).toEqual(true);
    });
    it("today", () => {
      expect(
          testDateFilter(todayISOStr, FilterOperator.Is, {mode: DateFilterMode.today})
      ).toEqual(true);
    });
    it("tomorrow", () => {
      expect(
          testDateFilter(getRelativeDate(1), FilterOperator.Is, {mode: DateFilterMode.tomorrow})
      ).toEqual(true);
    });
    it("oneWeekAgo", () => {
      expect(
          testDateFilter(getRelativeDate(-7), FilterOperator.Is, {mode: DateFilterMode.PastWeek})
      ).toEqual(true);
      expect(
          testDateFilter(todayISOStr, FilterOperator.Is, {mode: DateFilterMode.PastWeek})
      ).toEqual(false);
    });
    it("oneWeekFromNow", () => {
      expect(
          testDateFilter(getRelativeDate(7), FilterOperator.Is, {
            mode: DateFilterMode.NextWeek,
          })
      ).toEqual(true);
      expect(
          testDateFilter(todayISOStr, FilterOperator.Is, {mode: DateFilterMode.NextWeek})
      ).toEqual(false);
    });
    it("PastMonth", () => {
      expect(
          testDateFilter(getRelativeDate(-30), FilterOperator.Is, {mode: DateFilterMode.PastMonth})
      ).toEqual(true);
      expect(
          testDateFilter(todayISOStr, FilterOperator.Is, {mode: DateFilterMode.PastMonth})
      ).toEqual(false);
    });
    it("NextMonth", () => {
      expect(
          testDateFilter(getRelativeDate(30), FilterOperator.Is, {
            mode: DateFilterMode.NextMonth,
          })
      ).toEqual(true);
      expect(testDateFilter(todayISOStr, FilterOperator.Is, {
            mode: DateFilterMode.NextMonth,
          })
      ).toEqual(false);
    });
    it("LastWeek", () => {
      // 上周1-7
      for (let index = 1; index <= 7; index++) {
        if (index === 7)
          return expect(
              testDateFilter(
                  dayjs().subtract(1, "week").startOf('week').format("YYYY-MM-DD"),
                  FilterOperator.Is,
                  {mode: DateFilterMode.LastWeek}
              )
          ).toEqual(true);
        expect(
            testDateFilter(
                dayjs().subtract(1, "week").day(index).format("YYYY-MM-DD"),
                FilterOperator.Is,
                {mode: DateFilterMode.LastWeek}
            )
        ).toEqual(true);
      }
    });
    it("LastMouth", () => {
      // 上个月1号
      const LastMouthOneIOSStr = dayjs().subtract(1, "month").day(1).format("YYYY-MM-DD");
      // 上个月最后一天
      const LastMouthLastDayIOSStr = dayjs()
          .subtract(1, "month")
          .endOf("month")
          .format("YYYY-MM-DD");
      expect(testDateFilter(LastMouthOneIOSStr, FilterOperator.Is, {mode: DateFilterMode.LastMonth})).toEqual(true);
      expect(
          testDateFilter(LastMouthLastDayIOSStr, FilterOperator.Is, {
            mode: DateFilterMode.LastMonth,
          })
      ).toEqual(true);
    });
    it("ThisWeek", () => {
      expect(
          testDateFilter(todayISOStr, FilterOperator.Is, {mode: DateFilterMode.ThisWeek})
      ).toEqual(true);
    });
    it("ThisMonth", () => {
      expect(
          testDateFilter(todayISOStr, FilterOperator.Is, {mode: DateFilterMode.ThisMonth})
      ).toEqual(true);
    });
    it("PastNumberOfDays", () => {
      const numberOfDays = 10;
      expect(
          testDateFilter(todayISOStr, FilterOperator.Is, {
            mode: DateFilterMode.PastNumberOfDays,
            numberOfDays,
          })
      ).toEqual(false);
      expect(
          testDateFilter(getRelativeDate(-numberOfDays), FilterOperator.Is, {
            mode: DateFilterMode.PastNumberOfDays,
            numberOfDays,
          })
      ).toEqual(true);
    });
    it("NextNumberOfDays", () => {
      const numberOfDays = 10;
      expect(
          testDateFilter(todayISOStr, FilterOperator.Is, {
            mode: DateFilterMode.NextNumberOfDays,
            numberOfDays,
          })
      ).toEqual(false);
      expect(
          testDateFilter(getRelativeDate(numberOfDays), FilterOperator.Is, {
            mode: DateFilterMode.NextNumberOfDays,
            numberOfDays,
          })
      ).toEqual(true);
    });
  });
  describe('IsNot', () => {
    it("exactDate", () => {
      expect(
          testDateFilter(todayISOStr, FilterOperator.IsNot, {
            mode: DateFilterMode.exactDate,
            data: todayISOStr,
          })
      ).toEqual(false);
    });
    it("IsWithin", () => {
      expect(
          testDateFilter(dateRange[0], FilterOperator.IsNot, {
            mode: DateFilterMode.DateRange,
            data: dateRange,
          })
      ).toEqual(false);
      expect(
          testDateFilter(dateRange[1], FilterOperator.IsNot, {
            mode: DateFilterMode.DateRange,
            data: dateRange,
          })
      ).toEqual(false);
    });
    it("yesterday", () => {
      expect(
          testDateFilter(getRelativeDate(-1), FilterOperator.IsNot, {mode: DateFilterMode.yesterday})
      ).toEqual(false);
    });
    it("today", () => {
      expect(
          testDateFilter(todayISOStr, FilterOperator.IsNot, {mode: DateFilterMode.today})
      ).toEqual(false);
    });
    it("tomorrow", () => {
      expect(
          testDateFilter(getRelativeDate(1), FilterOperator.IsNot, {mode: DateFilterMode.tomorrow})
      ).toEqual(false);
    });
    it("oneWeekAgo", () => {
      expect(
          testDateFilter(getRelativeDate(-1), FilterOperator.IsNot, {mode: DateFilterMode.PastWeek})
      ).toEqual(false);
      expect(
          testDateFilter(todayISOStr, FilterOperator.IsNot, {mode: DateFilterMode.PastWeek})
      ).toEqual(true);
    });
    it("oneWeekFromNow", () => {
      expect(
          testDateFilter(getRelativeDate(7), FilterOperator.IsNot, {
            mode: DateFilterMode.NextWeek,
          })
      ).toEqual(false);
      expect(
          testDateFilter(todayISOStr, FilterOperator.IsNot, {mode: DateFilterMode.NextWeek})
      ).toEqual(true);
    });
    it("PastMonth", () => {
      expect(
          testDateFilter(getRelativeDate(-30), FilterOperator.IsNot, {mode: DateFilterMode.PastMonth})
      ).toEqual(false);
      expect(
          testDateFilter(todayISOStr, FilterOperator.IsNot, {mode: DateFilterMode.PastMonth})
      ).toEqual(true);
    });
    it("NextMonth", () => {
      expect(
          testDateFilter(getRelativeDate(30), FilterOperator.IsNot, {
            mode: DateFilterMode.NextMonth,
          })
      ).toEqual(false);
      expect(
          testDateFilter(todayISOStr, FilterOperator.IsNot, {
            mode: DateFilterMode.NextMonth,
          })
      ).toEqual(true);
    });
    it("LastWeek", () => {
      // 上周1-7
      for (let index = 1; index <= 7; index++) {
        if (index === 7)
          return expect(
              testDateFilter(
                  dayjs().subtract(1, "week").startOf('week').format("YYYY-MM-DD"),
                  FilterOperator.IsNot,
                  {mode: DateFilterMode.LastWeek}
              )
          ).toEqual(false);
        expect(
            testDateFilter(
                dayjs().subtract(1, "week").day(index).format("YYYY-MM-DD"),
                FilterOperator.IsNot,
                {mode: DateFilterMode.LastWeek}
            )
        ).toEqual(false);
      }
    });
    it("LastMouth", () => {
      // 上个月1号
      const LastMouthOneIOSStr = dayjs().subtract(1, "month").day(1).format("YYYY-MM-DD");
      // 上个月最后一天
      const LastMouthLastDayIOSStr = dayjs()
          .subtract(1, "month")
          .endOf("month")
          .format("YYYY-MM-DD");
      expect(
          testDateFilter(LastMouthOneIOSStr, FilterOperator.IsNot, {mode: DateFilterMode.LastMonth})
      ).toEqual(false);
      expect(
          testDateFilter(LastMouthLastDayIOSStr, FilterOperator.IsNot, {
            mode: DateFilterMode.LastMonth,
          })
      ).toEqual(false);
    });
    it("ThisWeek", () => {
      expect(
          testDateFilter(todayISOStr, FilterOperator.IsNot, {mode: DateFilterMode.ThisWeek})
      ).toEqual(false);
    });
    it("ThisMonth", () => {
      expect(
          testDateFilter(todayISOStr, FilterOperator.IsNot, {mode: DateFilterMode.ThisMonth})
      ).toEqual(false);
    });
    it("PastNumberOfDays", () => {
      const numberOfDays = 10;
      expect(
          testDateFilter(todayISOStr, FilterOperator.IsNot, {
            mode: DateFilterMode.PastNumberOfDays,
            numberOfDays,
          })
      ).toEqual(true);
      expect(
          testDateFilter(getRelativeDate(-numberOfDays), FilterOperator.IsNot, {
            mode: DateFilterMode.PastNumberOfDays,
            numberOfDays,
          })
      ).toEqual(false);
    });
    it("NextNumberOfDays", () => {
      const numberOfDays = 10;
      expect(
          testDateFilter(todayISOStr, FilterOperator.IsNot, {
            mode: DateFilterMode.NextNumberOfDays,
            numberOfDays,
          })
      ).toEqual(true);
      expect(
          testDateFilter(getRelativeDate(numberOfDays), FilterOperator.IsNot, {
            mode: DateFilterMode.NextNumberOfDays,
            numberOfDays,
          })
      ).toEqual(false);
    });
  })
  describe('IsBefore', () => {
    it('exactDate', () => {
      expect(
          testDateFilter(dateRange[0], FilterOperator.IsBefore, {
            mode: DateFilterMode.exactDate,
            data: dateRange[1]
          })
      ).toEqual(true);
    })
    it('today', () => {
      expect(testDateFilter(todayISOStr, FilterOperator.IsBefore, {mode: DateFilterMode.today})).toEqual(false)
    })
    it('tomorrow', () => {
      expect(testDateFilter(todayISOStr, FilterOperator.IsBefore, {mode: DateFilterMode.tomorrow})).toEqual(true);
    })
    it('yesterday', () => {
      expect(testDateFilter(todayISOStr, FilterOperator.IsBefore, {mode: DateFilterMode.yesterday})).toEqual(false);
    })
    it('oneWeekAgo', () => {
      expect(testDateFilter(getRelativeDate(-7), FilterOperator.IsBefore, {mode: DateFilterMode.OneWeekAgo})).toEqual(false);
    })
    it('oneWeekFromNow', () => {
      expect(testDateFilter(getRelativeDate(7), FilterOperator.IsBefore, {mode: DateFilterMode.OneWeekFromNow})).toEqual(false);
    })
    it('oneMonthAgo', () => {
      expect(testDateFilter(getRelativeDate(-30), FilterOperator.IsBefore, {mode: DateFilterMode.oneMonthAgo})).toEqual(false);
    })
    it('oneMonthFromNow', () => {
      expect(testDateFilter(getRelativeDate(30), FilterOperator.IsBefore, {mode: DateFilterMode.oneMonthFromNow})).toEqual(false);
    })
    it('NumberOfDaysAgo', () => {
      const numberOfDays = 10;
      expect(testDateFilter(getRelativeDate(numberOfDays), FilterOperator.IsBefore, {
        mode: DateFilterMode.NumberOfDaysAgo,
        numberOfDays
      })).toEqual(false);
    })
    it('NumberOfDaysFromNow', () => {
      const numberOfDays = 10;
      expect(testDateFilter(getRelativeDate(numberOfDays), FilterOperator.IsBefore, {
        mode: DateFilterMode.NumberOfDaysFromNow,
        numberOfDays
      })).toEqual(false);
    })
  })
  describe('IsAfter', () => {
    it('exactDate', () => {
      expect(
          testDateFilter(dateRange[0], FilterOperator.IsAfter, {
            mode: DateFilterMode.exactDate,
            data: dateRange[1]
          })
      ).toEqual(false);
    })
    it('today', () => {
      expect(testDateFilter(todayISOStr, FilterOperator.IsAfter, {mode: DateFilterMode.today})).toEqual(false)
    })
    it('tomorrow', () => {
      expect(testDateFilter(todayISOStr, FilterOperator.IsAfter, {mode: DateFilterMode.tomorrow})).toEqual(false);
    })
    it('yesterday', () => {
      expect(testDateFilter(todayISOStr, FilterOperator.IsAfter, {mode: DateFilterMode.yesterday})).toEqual(true);
    })
    it('oneWeekAgo', () => {
      expect(testDateFilter(getRelativeDate(-7), FilterOperator.IsAfter, {mode: DateFilterMode.OneWeekAgo})).toEqual(false);
    })
    it('oneWeekFromNow', () => {
      expect(
          testDateFilter(getRelativeDate(7), FilterOperator.IsAfter, {mode: DateFilterMode.OneWeekFromNow})
      ).toEqual(false);
    })
    it('oneMonthAgo', () => {
      expect(
          testDateFilter(getRelativeDate(-30), FilterOperator.IsAfter, {mode: DateFilterMode.oneMonthAgo})
      ).toEqual(false);
    })
    it('oneMonthFromNow', () => {
      expect(
          testDateFilter(getRelativeDate(30), FilterOperator.IsAfter, {mode: DateFilterMode.oneMonthFromNow})
      ).toEqual(false);
    })
    it('NumberOfDaysAgo', () => {
      const numberOfDays = 10;
      let end = getRelativeDate(-numberOfDays);
      expect(
          testDateFilter(end, FilterOperator.IsAfter, {
            mode: DateFilterMode.NumberOfDaysAgo,
            numberOfDays
          })
      ).toEqual(false);
    })
    it('NumberOfDaysFromNow', () => {
      const numberOfDays = 10;
      expect(
          testDateFilter(getRelativeDate(numberOfDays), FilterOperator.IsAfter, {
            mode: DateFilterMode.NumberOfDaysFromNow,
            numberOfDays
          })
      ).toEqual(false);
    })
  })
});