@open-mercato/core 0.4.5-develop-2e9903a57a → 0.4.5-develop-eeccf7adf4

package/src/modules/translations/lib/__tests__/helpers.test.ts

@@ -1,215 +0,0 @@
-import {
-  formatFieldLabel,
-  formatEntityLabel,
-  buildEntityListUrl,
-  getRecordLabel,
-  resolveBaseValue,
-} from '../helpers'
-
-describe('translation helpers', () => {
-  describe('formatFieldLabel', () => {
-    it('converts snake_case to Title Case', () => {
-      expect(formatFieldLabel('product_name')).toBe('Product Name')
-    })
-
-    it('capitalizes single word', () => {
-      expect(formatFieldLabel('title')).toBe('Title')
-    })
-
-    it('formats option dot-path as "Value (option)"', () => {
-      expect(formatFieldLabel('options.red.label')).toBe('Red (option)')
-    })
-
-    it('formats option dot-path with lowercase value', () => {
-      expect(formatFieldLabel('options.blue.label')).toBe('Blue (option)')
-    })
-
-    it('formats generic dot-path with " > " separator', () => {
-      expect(formatFieldLabel('a.b.c')).toBe('A > B > C')
-    })
-
-    it('handles "description"', () => {
-      expect(formatFieldLabel('description')).toBe('Description')
-    })
-
-    it('returns original for empty string', () => {
-      expect(formatFieldLabel('')).toBe('')
-    })
-
-    it('handles multiple underscores', () => {
-      expect(formatFieldLabel('long_field_name_here')).toBe('Long Field Name Here')
-    })
-
-    it('handles dot-path with two segments', () => {
-      expect(formatFieldLabel('section.title')).toBe('Section > Title')
-    })
-
-    it('does not treat 4-segment option path as option', () => {
-      expect(formatFieldLabel('options.red.label.extra')).toBe('Options > Red > Label > Extra')
-    })
-  })
-
-  describe('formatEntityLabel', () => {
-    it('returns provided label when different from entityId', () => {
-      expect(formatEntityLabel('catalog:product', 'Product')).toBe('Product')
-    })
-
-    it('falls back to formatted name when label equals entityId', () => {
-      expect(formatEntityLabel('catalog:product', 'catalog:product')).toBe('Product')
-    })
-
-    it('falls back to formatted name when no label provided', () => {
-      expect(formatEntityLabel('catalog:catalog_product')).toBe('Catalog Product')
-    })
-
-    it('formats single-part entityId (no colon)', () => {
-      expect(formatEntityLabel('product')).toBe('Product')
-    })
-
-    it('falls back when label is undefined', () => {
-      expect(formatEntityLabel('catalog:offer', undefined)).toBe('Offer')
-    })
-
-    it('falls back when label is empty string', () => {
-      expect(formatEntityLabel('catalog:item', '')).toBe('Item')
-    })
-  })
-
-  describe('buildEntityListUrl', () => {
-    it('builds URL for standard entity type', () => {
-      expect(buildEntityListUrl('catalog:catalog_product')).toBe('/api/catalog/products')
-    })
-
-    it('builds URL when entity does not have module prefix', () => {
-      expect(buildEntityListUrl('catalog:offer')).toBe('/api/catalog/offers')
-    })
-
-    it('does not double-pluralize already-plural entity', () => {
-      expect(buildEntityListUrl('catalog:products')).toBe('/api/catalog/products')
-    })
-
-    it('returns null when no entity part after colon', () => {
-      expect(buildEntityListUrl('catalog:')).toBeNull()
-    })
-
-    it('returns null when no colon present', () => {
-      expect(buildEntityListUrl('catalog')).toBeNull()
-    })
-
-    it('returns null for empty string', () => {
-      expect(buildEntityListUrl('')).toBeNull()
-    })
-
-    it('strips module prefix from entity name', () => {
-      expect(buildEntityListUrl('sales:sales_order')).toBe('/api/sales/orders')
-    })
-
-    it('correctly pluralizes category', () => {
-      expect(buildEntityListUrl('catalog:category')).toBe('/api/catalog/categories')
-    })
-
-    it('correctly pluralizes entity ending in y after consonant', () => {
-      expect(buildEntityListUrl('catalog:catalog_company')).toBe('/api/catalog/companies')
-    })
-
-    it('correctly pluralizes entity ending in x', () => {
-      expect(buildEntityListUrl('catalog:catalog_box')).toBe('/api/catalog/boxes')
-    })
-
-    it('correctly pluralizes entity ending in sh', () => {
-      expect(buildEntityListUrl('catalog:catalog_dish')).toBe('/api/catalog/dishes')
-    })
-
-    it('correctly pluralizes entity ending in ch', () => {
-      expect(buildEntityListUrl('catalog:catalog_match')).toBe('/api/catalog/matches')
-    })
-
-    it('replaces underscores with hyphens in multi-word resource names', () => {
-      expect(buildEntityListUrl('resources:resource_type')).toBe('/api/resources/resource-types')
-    })
-
-    it('replaces underscores with hyphens after prefix stripping', () => {
-      expect(buildEntityListUrl('catalog:catalog_product_category')).toBe('/api/catalog/product-categories')
-    })
-
-    it('handles entity with underscores and plural exception', () => {
-      expect(buildEntityListUrl('dictionaries:dictionary_entry')).toBe('/api/dictionaries/dictionary-entries')
-    })
-  })
-
-  describe('getRecordLabel', () => {
-    it('returns title when present', () => {
-      expect(getRecordLabel({ title: 'Foo' })).toBe('Foo')
-    })
-
-    it('falls back to name when no title', () => {
-      expect(getRecordLabel({ name: 'Bar' })).toBe('Bar')
-    })
-
-    it('falls back to label when no title or name', () => {
-      expect(getRecordLabel({ label: 'Baz' })).toBe('Baz')
-    })
-
-    it('falls back to display_name', () => {
-      expect(getRecordLabel({ display_name: 'Display' })).toBe('Display')
-    })
-
-    it('falls back to id', () => {
-      expect(getRecordLabel({ id: '123' })).toBe('123')
-    })
-
-    it('returns empty string for empty object', () => {
-      expect(getRecordLabel({})).toBe('')
-    })
-
-    it('title takes priority over name', () => {
-      expect(getRecordLabel({ title: 'A', name: 'B' })).toBe('A')
-    })
-
-    it('name takes priority over label', () => {
-      expect(getRecordLabel({ name: 'N', label: 'L', id: 'X' })).toBe('N')
-    })
-
-    it('converts non-string values to string', () => {
-      expect(getRecordLabel({ id: 42 })).toBe('42')
-    })
-  })
-
-  describe('resolveBaseValue', () => {
-    it('returns direct field value', () => {
-      expect(resolveBaseValue({ name: 'Foo' }, 'name')).toBe('Foo')
-    })
-
-    it('falls back to cf_ prefixed field', () => {
-      expect(resolveBaseValue({ cf_priority: 'High' }, 'priority')).toBe('High')
-    })
-
-    it('prefers direct match over cf_ prefixed', () => {
-      expect(resolveBaseValue({ name: 'Direct', cf_name: 'Custom' }, 'name')).toBe('Direct')
-    })
-
-    it('returns empty string for missing field', () => {
-      expect(resolveBaseValue({ other: 'val' }, 'name')).toBe('')
-    })
-
-    it('returns empty string for null baseValues', () => {
-      expect(resolveBaseValue(null, 'name')).toBe('')
-    })
-
-    it('returns empty string for undefined baseValues', () => {
-      expect(resolveBaseValue(undefined, 'name')).toBe('')
-    })
-
-    it('returns empty string for null field value', () => {
-      expect(resolveBaseValue({ description: null }, 'description')).toBe('')
-    })
-
-    it('converts numeric value to string', () => {
-      expect(resolveBaseValue({ cf_mileage: 22610 }, 'mileage')).toBe('22610')
-    })
-
-    it('converts boolean value to string', () => {
-      expect(resolveBaseValue({ cf_active: true }, 'active')).toBe('true')
-    })
-  })
-})

package/src/modules/translations/lib/__tests__/locale.test.ts

@@ -1,115 +0,0 @@
-import { resolveLocaleFromRequest } from '../locale'
-
-function makeRequest(url: string, headers: Record<string, string> = {}): Request {
-  return new Request(url, { headers })
-}
-
-describe('resolveLocaleFromRequest', () => {
-  describe('query parameter', () => {
-    it('returns locale from ?locale= query param', () => {
-      const req = makeRequest('https://example.com/api/products?locale=de')
-      expect(resolveLocaleFromRequest(req)).toBe('de')
-    })
-
-    it('returns locale from query param with other params', () => {
-      const req = makeRequest('https://example.com/api/products?page=1&locale=fr&pageSize=10')
-      expect(resolveLocaleFromRequest(req)).toBe('fr')
-    })
-
-    it('ignores query param shorter than 2 chars', () => {
-      const req = makeRequest('https://example.com/api/products?locale=x')
-      expect(resolveLocaleFromRequest(req)).toBeNull()
-    })
-
-    it('ignores query param longer than 10 chars', () => {
-      const req = makeRequest('https://example.com/api/products?locale=abcdefghijk')
-      expect(resolveLocaleFromRequest(req)).toBeNull()
-    })
-  })
-
-  describe('X-Locale header', () => {
-    it('returns locale from X-Locale header', () => {
-      const req = makeRequest('https://example.com/api/products', { 'x-locale': 'es' })
-      expect(resolveLocaleFromRequest(req)).toBe('es')
-    })
-
-    it('ignores X-Locale header shorter than 2 chars', () => {
-      const req = makeRequest('https://example.com/api/products', { 'x-locale': 'a' })
-      expect(resolveLocaleFromRequest(req)).toBeNull()
-    })
-
-    it('ignores X-Locale header longer than 10 chars', () => {
-      const req = makeRequest('https://example.com/api/products', { 'x-locale': 'abcdefghijk' })
-      expect(resolveLocaleFromRequest(req)).toBeNull()
-    })
-  })
-
-  describe('cookie', () => {
-    it('returns locale from cookie', () => {
-      const req = makeRequest('https://example.com/api/products', { cookie: 'locale=pl' })
-      expect(resolveLocaleFromRequest(req)).toBe('pl')
-    })
-
-    it('extracts locale from cookie among other cookies', () => {
-      const req = makeRequest('https://example.com/api/products', { cookie: 'session=abc; locale=de; theme=dark' })
-      expect(resolveLocaleFromRequest(req)).toBe('de')
-    })
-
-    it('ignores cookie value shorter than 2 chars', () => {
-      const req = makeRequest('https://example.com/api/products', { cookie: 'locale=x' })
-      expect(resolveLocaleFromRequest(req)).toBeNull()
-    })
-  })
-
-  describe('Accept-Language header', () => {
-    it('returns matching locale from Accept-Language (single supported)', () => {
-      const req = makeRequest('https://example.com/api/products', { 'accept-language': 'pl;q=1.0' })
-      expect(resolveLocaleFromRequest(req)).toBe('pl')
-    })
-
-    it('matches first supported locale found in Accept-Language', () => {
-      // locales array is ['en', 'pl', 'es', 'de'] — en is checked first
-      const req = makeRequest('https://example.com/api/products', { 'accept-language': 'de-DE,de;q=0.9,en;q=0.8' })
-      expect(resolveLocaleFromRequest(req)).toBe('en')
-    })
-
-    it('returns de when Accept-Language only contains de', () => {
-      const req = makeRequest('https://example.com/api/products', { 'accept-language': 'de-DE,de;q=0.9' })
-      expect(resolveLocaleFromRequest(req)).toBe('de')
-    })
-
-    it('returns null when Accept-Language has no matching locale', () => {
-      const req = makeRequest('https://example.com/api/products', { 'accept-language': 'ja,zh;q=0.9' })
-      expect(resolveLocaleFromRequest(req)).toBeNull()
-    })
-  })
-
-  describe('priority ordering', () => {
-    it('query param takes priority over header', () => {
-      const req = makeRequest('https://example.com/api/products?locale=de', { 'x-locale': 'fr' })
-      expect(resolveLocaleFromRequest(req)).toBe('de')
-    })
-
-    it('X-Locale header takes priority over cookie', () => {
-      const req = makeRequest('https://example.com/api/products', { 'x-locale': 'es', cookie: 'locale=pl' })
-      expect(resolveLocaleFromRequest(req)).toBe('es')
-    })
-
-    it('cookie takes priority over Accept-Language', () => {
-      const req = makeRequest('https://example.com/api/products', { cookie: 'locale=de', 'accept-language': 'en,pl;q=0.9' })
-      expect(resolveLocaleFromRequest(req)).toBe('de')
-    })
-  })
-
-  describe('fallback', () => {
-    it('returns null when no locale source is present', () => {
-      const req = makeRequest('https://example.com/api/products')
-      expect(resolveLocaleFromRequest(req)).toBeNull()
-    })
-
-    it('returns null when all sources are empty', () => {
-      const req = makeRequest('https://example.com/api/products', { cookie: 'session=abc' })
-      expect(resolveLocaleFromRequest(req)).toBeNull()
-    })
-  })
-})

package/src/modules/translations/lib/__tests__/resolve-field-list.test.ts

@@ -1,176 +0,0 @@
-import { registerTranslatableFields } from '@open-mercato/shared/lib/localization/translatable-fields'
-
-jest.mock('#generated/entity-fields-registry', () => ({
-  getEntityFields: jest.fn(),
-}))
-
-import { getEntityFields } from '#generated/entity-fields-registry'
-import { resolveFieldList } from '../resolve-field-list'
-
-const mockedGetEntityFields = getEntityFields as jest.MockedFunction<typeof getEntityFields>
-
-beforeEach(() => {
-  mockedGetEntityFields.mockReset()
-})
-
-describe('resolveFieldList', () => {
-  describe('explicit fields', () => {
-    it('returns explicit fields when provided', () => {
-      const result = resolveFieldList('catalog:product', ['title', 'description'], [])
-      expect(result).toEqual([
-        { key: 'title', label: 'Title', multiline: false },
-        { key: 'description', label: 'Description', multiline: true },
-      ])
-    })
-
-    it('marks content fields as multiline', () => {
-      const result = resolveFieldList('catalog:product', ['content', 'short_description'], [])
-      expect(result).toEqual([
-        { key: 'content', label: 'Content', multiline: true },
-        { key: 'short_description', label: 'Short Description', multiline: true },
-      ])
-    })
-
-    it('ignores registry and entity fields when explicit fields given', () => {
-      registerTranslatableFields({ 'test:explicit_priority': ['name', 'description'] })
-      const result = resolveFieldList('test:explicit_priority', ['title'], [])
-      expect(result).toHaveLength(1)
-      expect(result[0].key).toBe('title')
-    })
-
-    it('ignores custom field defs when explicit fields given', () => {
-      const result = resolveFieldList('catalog:product', ['title'], [
-        { key: 'custom_note', kind: 'text' },
-      ])
-      expect(result).toHaveLength(1)
-      expect(result[0].key).toBe('title')
-    })
-  })
-
-  describe('registered translatable fields', () => {
-    it('uses registered fields when no explicit fields', () => {
-      registerTranslatableFields({ 'test:registered': ['name', 'description', 'content'] })
-      const result = resolveFieldList('test:registered', undefined, [])
-      expect(result).toEqual([
-        { key: 'name', label: 'Name', multiline: false },
-        { key: 'description', label: 'Description', multiline: true },
-        { key: 'content', label: 'Content', multiline: true },
-      ])
-    })
-
-    it('does not call getEntityFields when registered fields exist', () => {
-      registerTranslatableFields({ 'test:no_entity_lookup': ['title'] })
-      resolveFieldList('test:no_entity_lookup', undefined, [])
-      expect(mockedGetEntityFields).not.toHaveBeenCalled()
-    })
-  })
-
-  describe('auto-detect via getEntityFields', () => {
-    it('auto-detects translatable fields from entity fields', () => {
-      mockedGetEntityFields.mockReturnValue({
-        field1: 'title',
-        field2: 'name',
-        field3: 'id',
-        field4: 'created_at',
-        field5: 'sku',
-      })
-      const result = resolveFieldList('unknown:my_entity', undefined, [])
-      expect(mockedGetEntityFields).toHaveBeenCalledWith('my_entity')
-      expect(result.map((f) => f.key)).toEqual(['title', 'name'])
-    })
-
-    it('skips non-string and empty values', () => {
-      mockedGetEntityFields.mockReturnValue({
-        field1: 'title',
-        field2: '',
-        field3: '   ',
-        field4: null as unknown as string,
-      })
-      const result = resolveFieldList('unknown:test_entity', undefined, [])
-      expect(result).toHaveLength(1)
-      expect(result[0].key).toBe('title')
-    })
-
-    it('deduplicates fields', () => {
-      mockedGetEntityFields.mockReturnValue({
-        field1: 'title',
-        field2: 'title',
-      })
-      const result = resolveFieldList('unknown:dup_entity', undefined, [])
-      expect(result).toHaveLength(1)
-    })
-
-    it('returns empty when entity slug is missing', () => {
-      const result = resolveFieldList('nocolon', undefined, [])
-      expect(result).toEqual([])
-    })
-
-    it('returns empty when getEntityFields returns null', () => {
-      mockedGetEntityFields.mockReturnValue(null)
-      const result = resolveFieldList('unknown:missing_entity', undefined, [])
-      expect(result).toEqual([])
-    })
-  })
-
-  describe('custom field defs augmentation', () => {
-    it('appends text custom fields', () => {
-      registerTranslatableFields({ 'test:with_cf': ['title'] })
-      const result = resolveFieldList('test:with_cf', undefined, [
-        { key: 'custom_note', kind: 'text', label: 'Custom Note' },
-      ])
-      expect(result).toHaveLength(2)
-      expect(result[1]).toEqual({ key: 'custom_note', label: 'Custom Note', multiline: false })
-    })
-
-    it('appends multiline custom fields as multiline', () => {
-      registerTranslatableFields({ 'test:with_multiline_cf': ['title'] })
-      const result = resolveFieldList('test:with_multiline_cf', undefined, [
-        { key: 'long_text', kind: 'multiline' },
-      ])
-      expect(result[1].multiline).toBe(true)
-    })
-
-    it('appends richtext custom fields as multiline', () => {
-      registerTranslatableFields({ 'test:with_richtext_cf': ['title'] })
-      const result = resolveFieldList('test:with_richtext_cf', undefined, [
-        { key: 'rich_content', kind: 'richtext' },
-      ])
-      expect(result[1].multiline).toBe(true)
-    })
-
-    it('skips non-text kinds (number, boolean, etc.)', () => {
-      registerTranslatableFields({ 'test:skip_cf': ['title'] })
-      const result = resolveFieldList('test:skip_cf', undefined, [
-        { key: 'quantity', kind: 'number' },
-        { key: 'is_active', kind: 'boolean' },
-        { key: 'created_at', kind: 'date' },
-      ])
-      expect(result).toHaveLength(1)
-    })
-
-    it('does not duplicate fields already in the list', () => {
-      registerTranslatableFields({ 'test:no_dup_cf': ['title'] })
-      const result = resolveFieldList('test:no_dup_cf', undefined, [
-        { key: 'title', kind: 'text' },
-      ])
-      expect(result).toHaveLength(1)
-    })
-
-    it('uses formatFieldLabel when custom field has no label', () => {
-      registerTranslatableFields({ 'test:cf_no_label': ['title'] })
-      const result = resolveFieldList('test:cf_no_label', undefined, [
-        { key: 'product_note', kind: 'text' },
-      ])
-      expect(result[1].label).toBe('Product Note')
-    })
-
-    it('skips custom fields with empty key', () => {
-      registerTranslatableFields({ 'test:cf_empty_key': ['title'] })
-      const result = resolveFieldList('test:cf_empty_key', undefined, [
-        { key: '', kind: 'text' },
-        { key: '  ', kind: 'text' },
-      ])
-      expect(result).toHaveLength(1)
-    })
-  })
-})

package/src/modules/translations/lib/__tests__/translatable-fields.test.ts

@@ -1,79 +0,0 @@
-import { isTranslatableField } from '../translatable-fields'
-
-describe('isTranslatableField', () => {
-  describe('translatable fields (returns true)', () => {
-    it.each([
-      'title',
-      'name',
-      'description',
-      'content',
-      'short_description',
-      'style_code',
-      'summary',
-      'bio',
-      'notes',
-    ])('"%s" is translatable', (field) => {
-      expect(isTranslatableField(field)).toBe(true)
-    })
-  })
-
-  describe('exact blacklist (returns false)', () => {
-    it.each([
-      'id',
-      'created_at',
-      'updated_at',
-      'deleted_at',
-      'tenant_id',
-      'organization_id',
-      'is_active',
-      'sort_order',
-      'position',
-      'slug',
-      'sku',
-      'barcode',
-      'price',
-      'quantity',
-      'weight',
-      'width',
-      'height',
-      'depth',
-      'metadata',
-      'config',
-      'settings',
-      'options',
-    ])('"%s" is not translatable (exact blacklist)', (field) => {
-      expect(isTranslatableField(field)).toBe(false)
-    })
-  })
-
-  describe('suffix blacklist (returns false)', () => {
-    it.each([
-      ['product_id', '_id'],
-      ['category_id', '_id'],
-      ['updated_at', '_at'],
-      ['expires_at', '_at'],
-      ['password_hash', '_hash'],
-      ['token_hash', '_hash'],
-    ])('"%s" is not translatable (suffix %s)', (field) => {
-      expect(isTranslatableField(field)).toBe(false)
-    })
-  })
-
-  describe('case insensitivity', () => {
-    it('rejects uppercase "ID"', () => {
-      expect(isTranslatableField('ID')).toBe(false)
-    })
-
-    it('rejects mixed case "Created_At"', () => {
-      expect(isTranslatableField('Created_At')).toBe(false)
-    })
-
-    it('rejects uppercase "SKU"', () => {
-      expect(isTranslatableField('SKU')).toBe(false)
-    })
-
-    it('rejects "METADATA"', () => {
-      expect(isTranslatableField('METADATA')).toBe(false)
-    })
-  })
-})

package/src/modules/translations/widgets/__tests__/injection-table.test.ts

@@ -1,83 +0,0 @@
-import { injectionTable } from '../injection-table'
-import { translatableFields as catalogFields } from '../../../catalog/translations'
-import { translatableFields as dictionaryFields } from '../../../dictionaries/translations'
-import { translatableFields as entitiesFields } from '../../../entities/translations'
-import { translatableFields as resourcesFields } from '../../../resources/translations'
-
-const allExpectedEntityTypes = [
-  ...Object.keys(catalogFields),
-  ...Object.keys(dictionaryFields),
-  ...Object.keys(entitiesFields),
-  ...Object.keys(resourcesFields),
-]
-
-describe('translations injection-table', () => {
-  it('generates a full-form entry for every translatable entity type', () => {
-    for (const entityType of allExpectedEntityTypes) {
-      const spotId = `crud-form:${entityType.replace(/:/g, '.')}`
-      expect(injectionTable[spotId]).toBeDefined()
-    }
-  })
-
-  it('generates short-form entries for entity types with module prefix', () => {
-    // catalog:catalog_product → short form: crud-form:catalog.product
-    expect(injectionTable['crud-form:catalog.product']).toBeDefined()
-    expect(injectionTable['crud-form:catalog.product_variant']).toBeDefined()
-    expect(injectionTable['crud-form:catalog.offer']).toBeDefined()
-    expect(injectionTable['crud-form:catalog.product_category']).toBeDefined()
-    expect(injectionTable['crud-form:catalog.product_tag']).toBeDefined()
-    expect(injectionTable['crud-form:catalog.option_schema_template']).toBeDefined()
-  })
-
-  it('does not generate short-form for entries without module prefix', () => {
-    // dictionaries:dictionary_entry → prefix is "dictionaries_", slug is "dictionary_entry"
-    // "dictionary_entry" does NOT start with "dictionaries_", so no short form
-    expect(injectionTable['crud-form:dictionaries.dictionary_entry']).toBeDefined()
-  })
-
-  it('uses the correct widget ID for all entries', () => {
-    const widgetId = 'translations.injection.translation-manager'
-    for (const slots of Object.values(injectionTable)) {
-      const slotsArray = Array.isArray(slots) ? slots : [slots]
-      for (const slot of slotsArray) {
-        const resolved = typeof slot === 'string' ? slot : slot.widgetId
-        expect(resolved).toBe(widgetId)
-      }
-    }
-  })
-
-  it('places all widgets in column 2 with kind=group', () => {
-    for (const slots of Object.values(injectionTable)) {
-      const slotsArray = Array.isArray(slots) ? slots : [slots]
-      for (const slot of slotsArray) {
-        if (typeof slot !== 'string') {
-          expect(slot.column).toBe(2)
-          expect(slot.kind).toBe('group')
-        }
-      }
-    }
-  })
-
-  it('includes catalog:catalog_product in both full and short form', () => {
-    expect(injectionTable['crud-form:catalog.catalog_product']).toBeDefined()
-    expect(injectionTable['crud-form:catalog.product']).toBeDefined()
-  })
-
-  it('includes dictionaries:dictionary_entry spot', () => {
-    expect(injectionTable['crud-form:dictionaries.dictionary_entry']).toBeDefined()
-  })
-
-  it('includes entities:custom_field_def spot', () => {
-    expect(injectionTable['crud-form:entities.custom_field_def']).toBeDefined()
-  })
-
-  it('includes resources:resources_resource in both full and short form', () => {
-    expect(injectionTable['crud-form:resources.resources_resource']).toBeDefined()
-    expect(injectionTable['crud-form:resources.resource']).toBeDefined()
-  })
-
-  it('includes resources:resources_resource_type in both full and short form', () => {
-    expect(injectionTable['crud-form:resources.resources_resource_type']).toBeDefined()
-    expect(injectionTable['crud-form:resources.resource_type']).toBeDefined()
-  })
-})