contentstack-typescript/test/api/asset.spec.ts at 117e7e6ca977de796c59a97c2f2f15004a89294c · contentstack/contentstack-typescript · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
/* eslint-disable no-console */
/* eslint-disable promise/always-return */
import { describe, it, expect, beforeAll, afterAll } from '@jest/globals';
import { BaseAsset } from 'src';
import { Asset } from '../../src/assets';
import { stackInstance } from '../utils/stack-instance';
import { TAsset } from './types';
import dotenv from 'dotenv';

dotenv.config();

const stack = stackInstance();
// Using new standardized env variable names
const assetUid = process.env.IMAGE_ASSET_UID || process.env.ASSET_UID || '';
describe('Asset API tests', () => {
  it('should check for asset is defined', async () => {
    const result = await makeAsset(assetUid).fetch<BaseAsset>();
    expect(result).toBeDefined();
    expect(result._version).toBeDefined();
    expect(result.uid).toBeDefined();
    expect(result.url).toBeDefined();
    expect(result.filename).toBeDefined();
    expect(result.created_by).toBeDefined();
    expect(result.updated_by).toBeDefined();
  });
  it('should check for include dimension', async () => {
    interface AssetWithDimension extends BaseAsset {
      dimension: {
        height: number;
        width: number;
      }
    }
    const result = await makeAsset(assetUid).includeDimension().fetch<AssetWithDimension>();
    expect(result.dimension).not.toEqual(undefined);
    expect(result._version).toBeDefined();
    expect(result.uid).toBeDefined();
    expect(result.url).toBeDefined();
    expect(result.filename).toBeDefined();
    expect(result.created_by).toBeDefined();
    expect(result.updated_by).toBeDefined();
  });
  it('should check for include branch', async () => {
    interface AssetWithBranch extends BaseAsset {
      _branch: string;
    }
    const result = await makeAsset(assetUid).includeBranch().fetch<AssetWithBranch>();
    expect(result._branch).not.toEqual(undefined);
    expect(result._version).toBeDefined();
    expect(result.uid).toBeDefined();
    expect(result.url).toBeDefined();
    expect(result.filename).toBeDefined();
    expect(result.created_by).toBeDefined();
    expect(result.updated_by).toBeDefined();
  });
  it('should check for include fallback', async () => {
    const result = await makeAsset(assetUid).includeFallback().fetch<BaseAsset>();
    expect(result._version).toBeDefined();
    expect(result.publish_details?.locale).toEqual('en-us');
    expect(result.uid).toBeDefined();
    expect(result.url).toBeDefined();
    expect(result.filename).toBeDefined();
    expect(result.created_by).toBeDefined();
    expect(result.updated_by).toBeDefined();
  });

  it('should check for relative urls', async () => {
    const result = await makeAsset(assetUid).relativeUrls().fetch<BaseAsset>();
    expect(result.url).not.toEqual(undefined);
    expect(result._version).toBeDefined();
    expect(result.uid).toBeDefined();
    expect(result.url).toBeDefined();
    expect(result.filename).toBeDefined();
    expect(result.created_by).toBeDefined();
    expect(result.updated_by).toBeDefined();
  });
  it('should check for version of asset', async () => {
    const result = await makeAsset(assetUid).version(1).fetch<BaseAsset>();
    expect(result._version).toEqual(1);
    expect(result.uid).toBeDefined();
    expect(result.url).toBeDefined();
    expect(result.filename).toBeDefined();
    expect(result.created_by).toBeDefined();
    expect(result.updated_by).toBeDefined();
  });
  it('should check for include metadata', async () => {

    interface AssetWithMetadata extends BaseAsset {
      _metadata: string;
    }
    const result = await makeAsset(assetUid).includeMetadata().fetch<AssetWithMetadata>();
    expect(result._metadata).not.toEqual(undefined);
    expect(result._version).toBeDefined();
    expect(result.uid).toBeDefined();
    expect(result.content_type).toBeDefined();
    expect(result.created_by).toBeDefined();
    expect(result.updated_by).toBeDefined();
  });
  it('should check for locale', async () => {
    const result = await makeAsset(assetUid).locale('en-us').fetch<BaseAsset>();
    expect(result._version).toEqual(1);
    expect(result.uid).toBeDefined();
    expect(result.content_type).toBeDefined();
    expect(result.created_by).toBeDefined();
    expect(result.updated_by).toBeDefined();
  });

  it('should fetch asset with asset_fields[] CDA param (user_defined_fields, embedded_metadata, ai_suggested, visual_markups)', async () => {
    const result = await makeAsset(assetUid)
      .assetFields('user_defined_fields', 'embedded_metadata', 'ai_suggested', 'visual_markups')
      .fetch<BaseAsset>();
    expect(result).toBeDefined();
    expect(result.uid).toBeDefined();
    expect(result._version).toBeDefined();
    expect(result.url).toBeDefined();
    expect(result.filename).toBeDefined();
  });
});
function makeAsset(uid = ''): Asset {
  const asset = stack.asset(uid);

  return asset;
}