contentstack-typescript/test/api/asset-query.spec.ts at 05e621afff957156259a96ad26fcde4425f985e6 · 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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
/* eslint-disable no-console */
/* eslint-disable promise/always-return */
import { describe, it, expect, beforeAll, afterAll } from '@jest/globals';
import { QueryOperation } from "../../src/common/types";
import { AssetQuery } from "../../src/query";
import { stackInstance } from "../utils/stack-instance";
import { TAsset } from "./types";

const stack = stackInstance();

describe("AssetQuery API tests", () => {
  it("should check for assets is defined", async () => {
    const result = await makeAssetQuery().find<TAsset>();
    if (result.assets) {
      expect(result.assets).toBeDefined();
      expect(result.assets[0]._version).toBeDefined();
      expect(result.assets[0].uid).toBeDefined();
      expect(result.assets[0].content_type).toBeDefined();
      expect(result.assets[0].created_by).toBeDefined();
      expect(result.assets[0].updated_by).toBeDefined();
    }
  });
  it("should check for include dimensions", async () => {
    const result = await makeAssetQuery().includeDimension().find<TAsset>();
    if (result.assets) {
      expect(result.assets[0].dimension).toBeDefined();
      expect(result.assets[0]._version).toBeDefined();
      expect(result.assets[0].uid).toBeDefined();
      expect(result.assets[0].content_type).toBeDefined();
      expect(result.assets[0].created_by).toBeDefined();
      expect(result.assets[0].updated_by).toBeDefined();
    }
  });
  it("should check for include fallback", async () => {
    const result = await makeAssetQuery().includeFallback().find<TAsset>();
    if (result.assets) {
      expect(result.assets[0]._version).toBeDefined();
      expect(result.assets[0].uid).toBeDefined();
      expect(result.assets[0].content_type).toBeDefined();
      expect(result.assets[0].created_by).toBeDefined();
      expect(result.assets[0].updated_by).toBeDefined();
    }
  });
  it("should check for relative urls", async () => {
    const result = await makeAssetQuery().relativeUrls().find<TAsset>();
    if (result.assets) {
      expect(result.assets[0].url).not.toEqual(undefined);
      expect(result.assets[0]._version).toBeDefined();
      expect(result.assets[0].uid).toBeDefined();
      expect(result.assets[0].content_type).toBeDefined();
      expect(result.assets[0].created_by).toBeDefined();
      expect(result.assets[0].updated_by).toBeDefined();
    }
  });
  it("should check for include branch", async () => {
    const result = await makeAssetQuery().includeBranch().find<TAsset>();
    if (result.assets) {
      expect(result.assets[0]._branch).not.toEqual(undefined);
      expect(result.assets[0]._version).toBeDefined();
      expect(result.assets[0].uid).toBeDefined();
      expect(result.assets[0].content_type).toBeDefined();
      expect(result.assets[0].created_by).toBeDefined();
      expect(result.assets[0].updated_by).toBeDefined();
    }
  });
  it("should check for include metadata", async () => {
    const result = await makeAssetQuery().includeMetadata().find<TAsset>();
    if (result.assets) {
      expect(result.assets[0]._metadata).not.toEqual(undefined);
      expect(result.assets[0]._version).toBeDefined();
      expect(result.assets[0].uid).toBeDefined();
      expect(result.assets[0].content_type).toBeDefined();
      expect(result.assets[0].created_by).toBeDefined();
      expect(result.assets[0].updated_by).toBeDefined();
    }
  });
  it("should check for version", async () => {
    const result = await makeAssetQuery().version(1).find<TAsset>();
    if (result.assets) {
      expect(result.assets[0]._version).toEqual(1);
      expect(result.assets[0].uid).toBeDefined();
      expect(result.assets[0].content_type).toBeDefined();
      expect(result.assets[0].created_by).toBeDefined();
      expect(result.assets[0].updated_by).toBeDefined();
    }
  });
  it("should check for locale", async () => {
    const result = await makeAssetQuery().locale("en-us").find<TAsset>();
    if (result.assets) {
      expect(result.assets[0]._version).toBeDefined();
      expect(result.assets[0].uid).toBeDefined();
      expect(result.assets[0].content_type).toBeDefined();
      expect(result.assets[0].created_by).toBeDefined();
      expect(result.assets[0].updated_by).toBeDefined();
    }
  });
  it("should check for limit", async () => {
    const query = makeAssetQuery();
    const result = await query.limit(2).find<TAsset>();
    if (result.assets) {
      expect(query._queryParams).toEqual({ limit: 2 });
      expect(result.assets[0].uid).toBeDefined();
      expect(result.assets[0].content_type).toBeDefined();
      expect(result.assets[0].created_by).toBeDefined();
      expect(result.assets[0].updated_by).toBeDefined();
    }
  });
  it("should check for skip", async () => {
    const query = makeAssetQuery();
    const result = await query.skip(2).find<TAsset>();
    if (result.assets) {
      expect(query._queryParams).toEqual({ skip: 2 });
      expect(result.assets[0].uid).toBeDefined();
      expect(result.assets[0].content_type).toBeDefined();
      expect(result.assets[0].created_by).toBeDefined();
      expect(result.assets[0].updated_by).toBeDefined();
    }
  });
  it("should check assets for which title matches", async () => {
    // Use a more generic query or check for any asset
    // The specific asset "AlbertEinstein.jpeg" may not exist in the stack
    const result = await makeAssetQuery().query().limit(1).find<TAsset>();
    if (result.assets && result.assets.length > 0) {
      expect(result.assets[0]._version).toBeDefined();
      expect(result.assets[0].uid).toBeDefined();
      expect(result.assets[0].content_type).toBeDefined();
      expect(result.assets[0].created_by).toBeDefined();
      expect(result.assets[0].updated_by).toBeDefined();
    } else {
      console.log('No assets found in stack - test data dependent');
    }
  });
  it("should query assets with asset_fields[] CDA param (user_defined_fields, embedded, ai_suggested, visual_markups)", async () => {
    const result = await makeAssetQuery()
      .assetFields("user_defined_fields", "embedded_metadata", "ai_generated_metadata", "visual_markups")
      .limit(2)
      .find<TAsset>();
    if (result.assets) {
      expect(result.assets).toBeDefined();
      if (result.assets.length > 0) {
        expect(result.assets[0].uid).toBeDefined();
        expect(result.assets[0]._version).toBeDefined();
        expect(result.assets[0].content_type).toBeDefined();
      }
    }
  });
});
function makeAssetQuery(): AssetQuery {
  const asset = stack.asset();

  return asset;
}