Function createDistinctTests

packages/db/tests/query/distinct.test.ts:124–723

(autoIndex: `off` | `eager`)

}

function createDistinctTests(autoIndex: `off` | `eager`): void {
  describe(`with autoIndex ${autoIndex}`, () => {
    describe(`Basic Usage`, () => {
      let usersCollection: ReturnType<typeof createUsersCollection>

      beforeEach(() => {
        usersCollection = createUsersCollection(autoIndex)
      })

      test(`distinct on a single column`, () => {
        const distinctCountries = createLiveQueryCollection({
          startSync: true,
          query: (q) =>
            q
              .from({ users: usersCollection })
              .select(({ users }) => ({ country: users.country }))
              .distinct(),
        })

        expect(distinctCountries.size).toBe(3) // USA, Canada, UK

        const countries = Array.from(distinctCountries.values()).map(
          (user) => user.country,
        )
        expect(countries).toContain(`USA`)
        expect(countries).toContain(`Canada`)
        expect(countries).toContain(`UK`)
        expect(countries.length).toBe(3)
      })

      test(`distinct on multiple columns`, () => {
        const distinctRoleSalary = createLiveQueryCollection({
          startSync: true,
          query: (q) =>
            q
              .from({ users: usersCollection })
              .select(({ users }) => ({
                role: users.role,
                salary: users.salary,
              }))
              .distinct(),
        })

        // Expected unique combinations:
        // Developer-75000 (John, Alice, Diana, Frank)
        // Developer-80000 (Jane)
        // Manager-90000 (Bob, Eve)
        // Representative-60000 (Charlie)
        expect(distinctRoleSalary.size).toBe(4)

        const combinations = Array.from(distinctRoleSalary.values()).map(
          (user) => `${user.role}-${user.salary}`,
        )
        expect(combinations).toContain(`Developer-75000`)
        expect(combinations).toContain(`Developer-80000`)
        expect(combinations).toContain(`Manager-90000`)
        expect(combinations).toContain(`Representative-60000`)
        expect(combinations.length).toBe(4)