universo-platform-2d

1
import type { Locator, Page } from '@playwright/test';
2
import { expect } from '@playwright/test';
3

4
export const getPropertyValueLocator = (page: Page, property: string) => {
5
  return page.locator(
6
    `[data-testid="doc-property-name"]:has-text("${property}") + *`
7
  );
8
};
9

10
export const ensurePagePropertiesVisible = async (page: Page) => {
11
  if (
12
    await page
13
      .getByRole('button', {
14
        name: 'Add property',
15
      })
16
      .isVisible()
17
  ) {
18
    return;
19
  }
20
  await page.getByTestId('page-info-collapse').click();
21
};
22

23
export const clickPropertyValue = async (page: Page, property: string) => {
24
  await getPropertyValueLocator(page, property).click();
25
};
26

27
export const openTagsEditor = async (page: Page) => {
28
  await clickPropertyValue(page, 'tags');
29
  await expect(page.getByTestId('tags-editor-popup')).toBeVisible();
30
};
31

32
export const closeTagsEditor = async (page: Page) => {
33
  await page.keyboard.press('Escape');
34
  await expect(page.getByTestId('tags-editor-popup')).not.toBeVisible();
35
};
36

37
export const clickTagFromSelector = async (page: Page, name: string) => {
38
  // assume that the tags editor is already open
39
  await page
40
    .locator(`[data-testid="tag-selector-item"][data-tag-value="${name}"]`)
41
    .click();
42
};
43

44
export const removeSelectedTag = async (page: Page, name: string) => {
45
  await page
46
    .locator(
47
      `[data-testid="tags-editor-popup"] [data-testid="inline-tags-list"] [data-tag-value="${name}"] [data-testid="remove-tag-button"]`
48
    )
49
    .click();
50
};
51

52
export const filterTags = async (page: Page, filter: string) => {
53
  await page
54
    .locator(
55
      '[data-testid="tags-editor-popup"] [data-testid="inline-tags-list"] input'
56
    )
57
    .fill(filter);
58
};
59

60
export const searchAndCreateTag = async (page: Page, name: string) => {
61
  await filterTags(page, name);
62
  await page
63
    .locator(
64
      '[data-testid="tags-editor-popup"] [data-testid="tag-selector-item"]:has-text("Create ")'
65
    )
66
    .click();
67
};
68

69
export const expectTagsVisible = async (
70
  root: Locator | Page,
71
  tags: string[]
72
) => {
73
  const tagListPanel = root
74
    .getByTestId('property-tags-value')
75
    .getByTestId('inline-tags-list');
76

77
  expect(await tagListPanel.locator('[data-tag-value]').count()).toBe(
78
    tags.length
79
  );
80

81
  for (const tag of tags) {
82
    await expect(
83
      tagListPanel.locator(`[data-tag-value="${tag}"]`)
84
    ).toBeVisible();
85
  }
86
};
87

88
export const clickAddPropertyButton = async (root: Locator | Page) => {
89
  await root
90
    .getByRole('button', {
91
      name: 'Add property',
92
    })
93
    .click();
94
};
95

96
export const ensureAddPropertyButtonVisible = async (
97
  page: Page,
98
  root: Locator | Page
99
) => {
100
  if (
101
    await root
102
      .getByRole('button', {
103
        name: 'Add property',
104
      })
105
      .isVisible()
106
  ) {
107
    return;
108
  }
109
  await togglePropertyListVisibility(page);
110
  await page.waitForTimeout(500);
111
  await expect(
112
    root.getByRole('button', { name: 'Add property' })
113
  ).toBeVisible();
114
};
115

116
export const togglePropertyListVisibility = async (page: Page) => {
117
  await page.getByTestId('property-collapsible-button').click();
118
};
119

120
export const addCustomProperty = async (
121
  page: Page,
122
  root: Locator | Page,
123
  type: string
124
) => {
125
  ensureAddPropertyButtonVisible(page, root);
126
  await clickAddPropertyButton(root);
127
  await page
128
    .locator(
129
      `[data-testid="${'create-property-menu-item'}"][data-property-type="${type}"]`
130
    )
131
    .click();
132
  if (await page.getByTestId('edit-property-menu-item').isVisible()) {
133
    // is edit property menu opened, close it
134
    await page.keyboard.press('Escape');
135
  }
136
  await page.waitForTimeout(500);
137
};
138

139
export const expectPropertyOrdering = async (
140
  page: Page,
141
  properties: string[]
142
) => {
143
  for (let i = 0; i < properties.length; i++) {
144
    await expect(
145
      page.locator(`[data-testid="page-property-row-name"])`).nth(i)
146
    ).toHaveText(properties[i]);
147
  }
148
};
149

150
export const openWorkspaceProperties = async (page: Page) => {
151
  await page.getByTestId('slider-bar-workspace-setting-button').click();
152
  await page
153
    .locator('[data-testid="workspace-list-item"] .setting-name')
154
    .click();
155
  await page.getByTestId('workspace-list-item-properties').click();
156
};
157

158
export const selectVisibilitySelector = async (
159
  page: Page,
160
  name: string,
161
  option: string
162
) => {
163
  await page
164
    .getByRole('menu')
165
    .locator(
166
      `[data-testid="page-properties-settings-menu-item"]:has-text("${name}")`
167
    )
168
    .getByRole('button')
169
    .click();
170

171
  await page
172
    .getByRole('menu')
173
    .last()
174
    .getByRole('menuitem', {
175
      name: option,
176
      exact: true,
177
    })
178
    .click();
179

180
  await page.waitForTimeout(500);
181

182
  await page.keyboard.press('Escape');
183

184
  await page.waitForTimeout(500);
185
};
186

187
export const changePropertyVisibility = async (
188
  page: Page,
189
  name: string,
190
  option: string
191
) => {
192
  await page
193
    .locator(`[data-testid="doc-property-name"]:has-text("${name}")`)
194
    .click();
195
  await page.locator(`[data-property-visibility="${option}"]`).click();
196
  await page.keyboard.press('Escape');
197
  await page.waitForTimeout(500);
198
};
199