@dossierhq/integration-test/lib/admin-entity/AdminEntityGetEntitiesTotalCountSubSuite.js

Integration test to ensure that different Dossier database adapters work as expected.

/// <reference types="./AdminEntityGetEntitiesTotalCountSubSuite.d.ts" />
import { copyEntity, EntityStatus } from '@dossierhq/core';
import { assertOkResult, assertResultValue, assertTruthy } from '../Asserts.js';
import { LOCATIONS_CREATE, REFERENCES_CREATE, TITLE_ONLY_CREATE, } from '../shared-entity/Fixtures.js';
import { randomBoundingBox } from '../shared-entity/LocationTestUtils.js';
export const GetEntitiesTotalCountSubSuite = [
    getEntitiesTotalCount_minimal,
    getEntitiesTotalCount_authKeySubject,
    getEntitiesTotalCount_authKeySubjectFromReadonlyRandom,
    getEntitiesTotalCount_authKeyNoneAndSubject,
    getEntitiesTotalCount_statusDraft,
    getEntitiesTotalCount_statusPublished,
    getEntitiesTotalCount_statusModified,
    getEntitiesTotalCount_statusWithdrawn,
    getEntitiesTotalCount_statusArchived,
    getEntitiesTotalCount_statusDraftArchived,
    getEntitiesTotalCount_statusModifiedPublished,
    getEntitiesTotalCount_statusAll,
    getEntitiesTotalCount_linksToOneReference,
    getEntitiesTotalCount_linksToNoReferences,
    getEntitiesTotalCount_linksToTwoReferencesFromOneEntity,
    getEntitiesTotalCount_linksFromOneReference,
    getEntitiesTotalCount_linksFromNoReferences,
    getEntitiesTotalCount_linksFromTwoReferencesFromOneEntity,
    getEntitiesTotalCount_boundingBoxOneInside,
];
async function getEntitiesTotalCount_minimal({ clientProvider, readOnlyEntityRepository, }) {
    const expectedEntities = readOnlyEntityRepository.getMainPrincipalAdminEntities();
    const result = await clientProvider.dossierClient().getEntitiesTotalCount({
        entityTypes: ['ReadOnly'],
    });
    assertResultValue(result, expectedEntities.length);
}
async function getEntitiesTotalCount_authKeySubject({ clientProvider, readOnlyEntityRepository, }) {
    const expectedEntities = readOnlyEntityRepository.getMainPrincipalAdminEntities({
        authKeys: ['subject'],
    });
    const result = await clientProvider.dossierClient().getEntitiesTotalCount({
        entityTypes: ['ReadOnly'],
        authKeys: ['subject'],
    });
    assertResultValue(result, expectedEntities.length);
}
async function getEntitiesTotalCount_authKeySubjectFromReadonlyRandom({ clientProvider, }) {
    const client = clientProvider.dossierClient('random', 'readonly');
    const result = await client.getEntitiesTotalCount({ authKeys: ['subject'] });
    assertResultValue(result, 0);
}
async function getEntitiesTotalCount_authKeyNoneAndSubject({ clientProvider, readOnlyEntityRepository, }) {
    const expectedEntities = readOnlyEntityRepository.getMainPrincipalAdminEntities({
        authKeys: ['', 'subject'],
    });
    const result = await clientProvider.dossierClient().getEntitiesTotalCount({
        entityTypes: ['ReadOnly'],
        authKeys: ['', 'subject'],
    });
    assertResultValue(result, expectedEntities.length);
}
async function getEntitiesTotalCount_statusDraft({ clientProvider, readOnlyEntityRepository, }) {
    const expectedEntities = readOnlyEntityRepository.getMainPrincipalAdminEntities({
        status: ['draft'],
    });
    const result = await clientProvider.dossierClient().getEntitiesTotalCount({
        entityTypes: ['ReadOnly'],
        status: [EntityStatus.draft],
    });
    assertResultValue(result, expectedEntities.length);
}
async function getEntitiesTotalCount_statusPublished({ clientProvider, readOnlyEntityRepository, }) {
    const expectedEntities = readOnlyEntityRepository.getMainPrincipalAdminEntities({
        status: ['published'],
    });
    const result = await clientProvider.dossierClient().getEntitiesTotalCount({
        entityTypes: ['ReadOnly'],
        status: [EntityStatus.published],
    });
    assertResultValue(result, expectedEntities.length);
}
async function getEntitiesTotalCount_statusModified({ clientProvider, readOnlyEntityRepository, }) {
    const expectedEntities = readOnlyEntityRepository.getMainPrincipalAdminEntities({
        status: ['modified'],
    });
    const result = await clientProvider.dossierClient().getEntitiesTotalCount({
        entityTypes: ['ReadOnly'],
        status: [EntityStatus.modified],
    });
    assertResultValue(result, expectedEntities.length);
}
async function getEntitiesTotalCount_statusWithdrawn({ clientProvider, readOnlyEntityRepository, }) {
    const expectedEntities = readOnlyEntityRepository.getMainPrincipalAdminEntities({
        status: ['withdrawn'],
    });
    const result = await clientProvider.dossierClient().getEntitiesTotalCount({
        entityTypes: ['ReadOnly'],
        status: [EntityStatus.withdrawn],
    });
    assertResultValue(result, expectedEntities.length);
}
async function getEntitiesTotalCount_statusArchived({ clientProvider, readOnlyEntityRepository, }) {
    const expectedEntities = readOnlyEntityRepository.getMainPrincipalAdminEntities({
        status: ['archived'],
    });
    const result = await clientProvider.dossierClient().getEntitiesTotalCount({
        entityTypes: ['ReadOnly'],
        status: [EntityStatus.archived],
    });
    assertResultValue(result, expectedEntities.length);
}
async function getEntitiesTotalCount_statusDraftArchived({ clientProvider, readOnlyEntityRepository, }) {
    const expectedEntities = readOnlyEntityRepository.getMainPrincipalAdminEntities({
        status: ['draft', 'archived'],
    });
    const result = await clientProvider.dossierClient().getEntitiesTotalCount({
        entityTypes: ['ReadOnly'],
        status: [EntityStatus.draft, EntityStatus.archived],
    });
    assertResultValue(result, expectedEntities.length);
}
async function getEntitiesTotalCount_statusModifiedPublished({ clientProvider, readOnlyEntityRepository, }) {
    const expectedEntities = readOnlyEntityRepository.getMainPrincipalAdminEntities({
        status: ['modified', 'published'],
    });
    const result = await clientProvider.dossierClient().getEntitiesTotalCount({
        entityTypes: ['ReadOnly'],
        status: [EntityStatus.modified, EntityStatus.published],
    });
    assertResultValue(result, expectedEntities.length);
}
async function getEntitiesTotalCount_statusAll({ clientProvider, readOnlyEntityRepository, }) {
    const expectedEntities = readOnlyEntityRepository.getMainPrincipalAdminEntities({
        status: [
            EntityStatus.draft,
            EntityStatus.modified,
            EntityStatus.published,
            EntityStatus.withdrawn,
            EntityStatus.archived,
        ],
    });
    const result = await clientProvider.dossierClient().getEntitiesTotalCount({
        entityTypes: ['ReadOnly'],
        status: [
            EntityStatus.draft,
            EntityStatus.modified,
            EntityStatus.published,
            EntityStatus.withdrawn,
            EntityStatus.archived,
        ],
    });
    assertResultValue(result, expectedEntities.length);
}
async function getEntitiesTotalCount_linksToOneReference({ clientProvider, }) {
    const client = clientProvider.dossierClient();
    const titleOnlyResult = await client.createEntity(TITLE_ONLY_CREATE);
    assertOkResult(titleOnlyResult);
    const { entity: { id: titleOnlyId }, } = titleOnlyResult.value;
    const referenceResult = await client.createEntity(copyEntity(REFERENCES_CREATE, { fields: { titleOnly: { id: titleOnlyId } } }));
    assertOkResult(referenceResult);
    const totalResult = await client.getEntitiesTotalCount({ linksTo: { id: titleOnlyId } });
    assertResultValue(totalResult, 1);
}
async function getEntitiesTotalCount_linksToNoReferences({ clientProvider, }) {
    const client = clientProvider.dossierClient();
    const titleOnlyResult = await client.createEntity(TITLE_ONLY_CREATE);
    assertOkResult(titleOnlyResult);
    const { entity: { id: titleOnlyId }, } = titleOnlyResult.value;
    const totalResult = await client.getEntitiesTotalCount({ linksTo: { id: titleOnlyId } });
    assertResultValue(totalResult, 0);
}
async function getEntitiesTotalCount_linksToTwoReferencesFromOneEntity({ clientProvider, }) {
    const client = clientProvider.dossierClient();
    const titleOnlyResult = await client.createEntity(TITLE_ONLY_CREATE);
    assertOkResult(titleOnlyResult);
    const { entity: { id: titleOnlyId }, } = titleOnlyResult.value;
    const referenceResult = await client.createEntity(copyEntity(REFERENCES_CREATE, {
        fields: { any: { id: titleOnlyId }, titleOnly: { id: titleOnlyId } },
    }));
    assertOkResult(referenceResult);
    const totalResult = await client.getEntitiesTotalCount({ linksTo: { id: titleOnlyId } });
    assertResultValue(totalResult, 1);
}
async function getEntitiesTotalCount_linksFromOneReference({ clientProvider, }) {
    const client = clientProvider.dossierClient();
    const titleOnlyResult = await client.createEntity(TITLE_ONLY_CREATE);
    assertOkResult(titleOnlyResult);
    const { entity: { id: titleOnlyId }, } = titleOnlyResult.value;
    const referenceResult = await client.createEntity(copyEntity(REFERENCES_CREATE, { fields: { titleOnly: { id: titleOnlyId } } }));
    assertOkResult(referenceResult);
    const { entity: { id: referenceId }, } = referenceResult.value;
    const totalResult = await client.getEntitiesTotalCount({ linksFrom: { id: referenceId } });
    assertResultValue(totalResult, 1);
}
async function getEntitiesTotalCount_linksFromNoReferences({ clientProvider, }) {
    const client = clientProvider.dossierClient();
    const referenceResult = await client.createEntity(REFERENCES_CREATE);
    assertOkResult(referenceResult);
    const { entity: { id }, } = referenceResult.value;
    const totalResult = await client.getEntitiesTotalCount({ linksFrom: { id } });
    assertResultValue(totalResult, 0);
}
async function getEntitiesTotalCount_linksFromTwoReferencesFromOneEntity({ clientProvider, }) {
    const client = clientProvider.dossierClient();
    const titleOnlyResult = await client.createEntity(TITLE_ONLY_CREATE);
    assertOkResult(titleOnlyResult);
    const { entity: { id: titleOnlyId }, } = titleOnlyResult.value;
    const referenceResult = await client.createEntity(copyEntity(REFERENCES_CREATE, {
        fields: { any: { id: titleOnlyId }, titleOnly: { id: titleOnlyId } },
    }));
    assertOkResult(referenceResult);
    const { entity: { id: referenceId }, } = referenceResult.value;
    const totalResult = await client.getEntitiesTotalCount({ linksFrom: { id: referenceId } });
    assertResultValue(totalResult, 1);
}
async function getEntitiesTotalCount_boundingBoxOneInside({ clientProvider, }) {
    const client = clientProvider.dossierClient();
    const boundingBox = randomBoundingBox();
    const center = {
        lat: (boundingBox.minLat + boundingBox.maxLat) / 2,
        lng: (boundingBox.minLng + boundingBox.maxLng) / 2,
    };
    const createResult = await client.createEntity(copyEntity(LOCATIONS_CREATE, { fields: { location: center } }));
    assertOkResult(createResult);
    const searchResult = await client.getEntities({ boundingBox }, { first: 100 });
    assertOkResult(searchResult);
    const searchCount = searchResult.value?.edges.length;
    assertTruthy(searchCount);
    const totalResult = await client.getEntitiesTotalCount({ boundingBox });
    assertResultValue(totalResult, searchCount);
}
//# sourceMappingURL=AdminEntityGetEntitiesTotalCountSubSuite.js.map