806 lines
21 KiB
TypeScript
806 lines
21 KiB
TypeScript
import { expect } from 'chai'
|
|
import 'mocha'
|
|
import { DeepPartial } from 'typeorm'
|
|
import { Highlight } from '../../src/entity/highlight'
|
|
import { Label } from '../../src/entity/label'
|
|
import { LibraryItem } from '../../src/entity/library_item'
|
|
import { User } from '../../src/entity/user'
|
|
import {
|
|
createHighlight,
|
|
findHighlightById,
|
|
} from '../../src/services/highlights'
|
|
import {
|
|
createLabel,
|
|
deleteLabels,
|
|
findLabelById,
|
|
findLabelsByLibraryItemId,
|
|
findLabelsByUserId,
|
|
saveLabelsInHighlight,
|
|
} from '../../src/services/labels'
|
|
import {
|
|
deleteLibraryItemById,
|
|
findLibraryItemById,
|
|
} from '../../src/services/library_item'
|
|
import { deleteUser } from '../../src/services/user'
|
|
import { createTestLibraryItem, createTestUser } from '../db'
|
|
import { generateFakeUuid, graphqlRequest, request } from '../util'
|
|
|
|
describe('Labels API', () => {
|
|
let user: User
|
|
let authToken: string
|
|
|
|
before(async () => {
|
|
// create test user and login
|
|
user = await createTestUser('fakeUser')
|
|
const res = await request
|
|
.post('/local/debug/fake-user-login')
|
|
.send({ fakeEmail: user.email })
|
|
authToken = res.body.authToken as string
|
|
})
|
|
|
|
after(async () => {
|
|
// clean up
|
|
await deleteUser(user.id)
|
|
})
|
|
|
|
describe('GET labels', () => {
|
|
let query: string
|
|
|
|
before(async () => {
|
|
// create testing labels
|
|
await createLabel('label_1', '#ffffff', user.id)
|
|
await createLabel('label_2', '#eeeeee', user.id)
|
|
})
|
|
|
|
after(async () => {
|
|
// clean up
|
|
await deleteLabels({ user: { id: user.id } }, user.id)
|
|
})
|
|
|
|
beforeEach(() => {
|
|
query = `
|
|
query {
|
|
labels {
|
|
... on LabelsSuccess {
|
|
labels {
|
|
id
|
|
name
|
|
color
|
|
description
|
|
createdAt
|
|
}
|
|
}
|
|
... on LabelsError {
|
|
errorCodes
|
|
}
|
|
}
|
|
}
|
|
`
|
|
})
|
|
|
|
it('should return labels', async () => {
|
|
const res = await graphqlRequest(query, authToken).expect(200)
|
|
|
|
const labels = await findLabelsByUserId(user.id)
|
|
expect(res.body.data.labels.labels).to.eql(
|
|
labels.map((label) => ({
|
|
id: label.id,
|
|
name: label.name,
|
|
color: label.color,
|
|
description: label.description,
|
|
createdAt: new Date(label.createdAt.setMilliseconds(0)).toISOString(),
|
|
}))
|
|
)
|
|
})
|
|
|
|
it('responds status code 400 when invalid query', async () => {
|
|
const invalidQuery = `
|
|
query {
|
|
labels {}
|
|
}
|
|
`
|
|
return graphqlRequest(invalidQuery, authToken).expect(400)
|
|
})
|
|
|
|
it('responds status code 500 when invalid user', async () => {
|
|
const invalidAuthToken = 'Fake token'
|
|
return graphqlRequest(query, invalidAuthToken).expect(500)
|
|
})
|
|
})
|
|
|
|
describe('Create label', () => {
|
|
const query = `
|
|
mutation CreateLabel($input: CreateLabelInput!) {
|
|
createLabel(input: $input) {
|
|
... on CreateLabelSuccess {
|
|
label {
|
|
id
|
|
name
|
|
}
|
|
}
|
|
... on CreateLabelError {
|
|
errorCodes
|
|
}
|
|
}
|
|
}
|
|
`
|
|
|
|
context('when name not exists', () => {
|
|
const name = 'label3'
|
|
|
|
after(async () => {
|
|
// clean up
|
|
await deleteLabels({ name }, user.id)
|
|
})
|
|
|
|
it('should create label', async () => {
|
|
const res = await graphqlRequest(query, authToken, {
|
|
input: { name },
|
|
}).expect(200)
|
|
const label = await findLabelById(
|
|
res.body.data.createLabel.label.id,
|
|
user.id
|
|
)
|
|
expect(label).to.exist
|
|
})
|
|
})
|
|
|
|
context('when name exists in the user library', () => {
|
|
let existingLabel: Label
|
|
|
|
before(async () => {
|
|
existingLabel = await createLabel('label3', '#ffffff', user.id)
|
|
})
|
|
|
|
after(async () => {
|
|
await deleteLabels({ id: existingLabel.id }, user.id)
|
|
})
|
|
|
|
it('should return error code LABEL_ALREADY_EXISTS', async () => {
|
|
const res = await graphqlRequest(query, authToken, {
|
|
input: { name: existingLabel.name },
|
|
}).expect(200)
|
|
|
|
expect(res.body.data.createLabel.errorCodes).to.eql([
|
|
'LABEL_ALREADY_EXISTS',
|
|
])
|
|
})
|
|
|
|
it('returns error code LABEL_ALREADY_EXISTS if case-insensitive label name exists', async () => {
|
|
const name = existingLabel.name.toUpperCase()
|
|
const res = await graphqlRequest(query, authToken, {
|
|
input: { name },
|
|
}).expect(200)
|
|
expect(res.body.data.createLabel.errorCodes).to.eql([
|
|
'LABEL_ALREADY_EXISTS',
|
|
])
|
|
})
|
|
})
|
|
|
|
context('when name exists in the other user library', () => {
|
|
let existingLabel: Label
|
|
let otherUser: User
|
|
|
|
before(async () => {
|
|
otherUser = await createTestUser('otherUser')
|
|
existingLabel = await createLabel('label3', '#ffffff', otherUser.id)
|
|
})
|
|
|
|
after(async () => {
|
|
// delete other user will also delete the label
|
|
await deleteUser(otherUser.id)
|
|
})
|
|
|
|
it('creates the label', async () => {
|
|
const res = await graphqlRequest(query, authToken, {
|
|
input: { name: existingLabel.name },
|
|
}).expect(200)
|
|
const label = await findLabelById(
|
|
res.body.data.createLabel.label.id,
|
|
user.id
|
|
)
|
|
expect(label).to.exist
|
|
})
|
|
})
|
|
|
|
it('responds status code 400 when invalid query', async () => {
|
|
const invalidQuery = `
|
|
mutation {
|
|
createLabel {}
|
|
}
|
|
`
|
|
return graphqlRequest(invalidQuery, authToken).expect(400)
|
|
})
|
|
|
|
it('responds status code 500 when invalid user', async () => {
|
|
const invalidAuthToken = 'Fake token'
|
|
return graphqlRequest(query, invalidAuthToken).expect(500)
|
|
})
|
|
})
|
|
|
|
describe('Delete label', () => {
|
|
let labelId: string
|
|
|
|
const query = `
|
|
mutation DeleteLabel($labelId: ID!){
|
|
deleteLabel(id: $labelId) {
|
|
... on DeleteLabelSuccess {
|
|
label {
|
|
id
|
|
name
|
|
}
|
|
}
|
|
... on DeleteLabelError {
|
|
errorCodes
|
|
}
|
|
}
|
|
}
|
|
`
|
|
|
|
context('when label exists', () => {
|
|
let toDeleteLabel: Label
|
|
|
|
context('when label is internal', () => {
|
|
before(async () => {
|
|
toDeleteLabel = await createLabel('rss', '#ffffff', user.id)
|
|
labelId = toDeleteLabel.id
|
|
})
|
|
|
|
it('should delete label', async () => {
|
|
await graphqlRequest(query, authToken, {
|
|
labelId,
|
|
}).expect(200)
|
|
|
|
const label = await findLabelById(labelId, user.id)
|
|
expect(label).not.exist
|
|
})
|
|
})
|
|
|
|
context('when label is not used', () => {
|
|
before(async () => {
|
|
toDeleteLabel = await createLabel(
|
|
'label not in use',
|
|
'#ffffff',
|
|
user.id
|
|
)
|
|
labelId = toDeleteLabel.id
|
|
})
|
|
|
|
it('should delete label', async () => {
|
|
await graphqlRequest(query, authToken, {
|
|
labelId,
|
|
}).expect(200)
|
|
const label = await findLabelById(labelId, user.id)
|
|
expect(label).not.exist
|
|
})
|
|
})
|
|
|
|
context('when a page has this label', () => {
|
|
let item: LibraryItem
|
|
|
|
before(async () => {
|
|
toDeleteLabel = await createLabel('page label', '#ffffff', user.id)
|
|
labelId = toDeleteLabel.id
|
|
item = await createTestLibraryItem(user.id, [toDeleteLabel])
|
|
})
|
|
|
|
after(async () => {
|
|
await deleteLibraryItemById(item.id)
|
|
})
|
|
|
|
it('should update page', async () => {
|
|
await graphqlRequest(query, authToken, {
|
|
labelId,
|
|
}).expect(200)
|
|
|
|
const updatedItem = await findLibraryItemById(item.id, user.id, {
|
|
relations: {
|
|
labels: true,
|
|
},
|
|
})
|
|
expect(updatedItem?.labels).not.deep.include(toDeleteLabel)
|
|
})
|
|
})
|
|
|
|
context('when a highlight has this label', () => {
|
|
const highlightId = generateFakeUuid()
|
|
let item: LibraryItem
|
|
|
|
before(async () => {
|
|
item = await createTestLibraryItem(user.id)
|
|
toDeleteLabel = await createLabel(
|
|
'highlight label',
|
|
'#ffffff',
|
|
user.id
|
|
)
|
|
const highlight: DeepPartial<Highlight> = {
|
|
id: highlightId,
|
|
patch: 'test patch',
|
|
quote: 'test quote',
|
|
shortId: 'test shortId',
|
|
user,
|
|
libraryItem: item,
|
|
}
|
|
await createHighlight(highlight, item.id, user.id)
|
|
await saveLabelsInHighlight([toDeleteLabel], highlightId)
|
|
})
|
|
|
|
after(async () => {
|
|
await deleteLibraryItemById(item.id)
|
|
})
|
|
|
|
it('should update highlight', async () => {
|
|
await graphqlRequest(query, authToken, {
|
|
labelId,
|
|
}).expect(200)
|
|
|
|
const updatedHighlight = await findHighlightById(highlightId, user.id)
|
|
expect(updatedHighlight?.labels).not.deep.include(toDeleteLabel)
|
|
})
|
|
})
|
|
})
|
|
|
|
context('when label not exist', () => {
|
|
before(() => {
|
|
labelId = generateFakeUuid()
|
|
})
|
|
|
|
it('should return error code NOT_FOUND', async () => {
|
|
const res = await graphqlRequest(query, authToken, {
|
|
labelId,
|
|
}).expect(200)
|
|
|
|
expect(res.body.data.deleteLabel.errorCodes).to.eql(['NOT_FOUND'])
|
|
})
|
|
})
|
|
|
|
it('responds status code 400 when invalid query', async () => {
|
|
const invalidQuery = `
|
|
mutation {
|
|
deleteLabel {}
|
|
}
|
|
`
|
|
return graphqlRequest(invalidQuery, authToken).expect(400)
|
|
})
|
|
|
|
it('responds status code 500 when invalid user', async () => {
|
|
const invalidAuthToken = 'Fake token'
|
|
return graphqlRequest(query, invalidAuthToken).expect(500)
|
|
})
|
|
})
|
|
|
|
describe('Set labels', () => {
|
|
let query: string
|
|
let itemId: string
|
|
let labelIds: string[] = []
|
|
let labels: Label[]
|
|
let item: LibraryItem
|
|
let source: string
|
|
|
|
before(async () => {
|
|
// create testing labels
|
|
const label1 = await createLabel('label_1', '#ffffff', user.id)
|
|
const label2 = await createLabel('label_2', '#eeeeee', user.id)
|
|
labels = [label1, label2]
|
|
item = await createTestLibraryItem(user.id)
|
|
source = 'user'
|
|
})
|
|
|
|
after(async () => {
|
|
// clean up
|
|
await deleteLabels({ user: { id: user.id } }, user.id)
|
|
await deleteLibraryItemById(item.id)
|
|
})
|
|
|
|
beforeEach(() => {
|
|
query = `
|
|
mutation {
|
|
setLabels(
|
|
input: {
|
|
pageId: "${itemId}",
|
|
labelIds: [
|
|
"${labelIds[0]}",
|
|
"${labelIds[1]}"
|
|
],
|
|
source: "${source}"
|
|
}
|
|
) {
|
|
... on SetLabelsSuccess {
|
|
labels {
|
|
id
|
|
name
|
|
}
|
|
}
|
|
... on SetLabelsError {
|
|
errorCodes
|
|
}
|
|
}
|
|
}
|
|
`
|
|
})
|
|
|
|
context('when labels exists', () => {
|
|
before(() => {
|
|
itemId = item.id
|
|
labelIds = [labels[0].id, labels[1].id]
|
|
source = 'rule:my-rule'
|
|
})
|
|
|
|
it('sets labels', async () => {
|
|
await graphqlRequest(query, authToken).expect(200)
|
|
const labels = await findLabelsByLibraryItemId(itemId, user.id)
|
|
expect(labels.map((l) => l.id)).to.eql(labelIds)
|
|
expect(labels[0].source).to.eql(source)
|
|
})
|
|
})
|
|
|
|
context('when labels not exist', () => {
|
|
before(() => {
|
|
itemId = item.id
|
|
labelIds = [generateFakeUuid(), generateFakeUuid()]
|
|
})
|
|
|
|
it('should return error code NOT_FOUND', async () => {
|
|
const res = await graphqlRequest(query, authToken).expect(200)
|
|
expect(res.body.data.setLabels.errorCodes).to.eql(['NOT_FOUND'])
|
|
})
|
|
})
|
|
|
|
context('when item not exist', () => {
|
|
before(() => {
|
|
itemId = generateFakeUuid()
|
|
labelIds = [labels[0].id, labels[1].id]
|
|
})
|
|
|
|
it('should return error code UNAUTHORIZED', async () => {
|
|
const res = await graphqlRequest(query, authToken).expect(200)
|
|
expect(res.body.data.setLabels.errorCodes).to.eql(['UNAUTHORIZED'])
|
|
})
|
|
})
|
|
|
|
it('responds status code 400 when invalid query', async () => {
|
|
const invalidQuery = `
|
|
mutation {
|
|
setLabels {}
|
|
}
|
|
`
|
|
return graphqlRequest(invalidQuery, authToken).expect(400)
|
|
})
|
|
|
|
it('responds status code 500 when invalid user', async () => {
|
|
const invalidAuthToken = 'Fake token'
|
|
return graphqlRequest(query, invalidAuthToken).expect(500)
|
|
})
|
|
})
|
|
|
|
describe('Update label', () => {
|
|
let query: string
|
|
let labelId: string
|
|
let name: string
|
|
let color: string
|
|
|
|
beforeEach(() => {
|
|
query = `
|
|
mutation {
|
|
updateLabel(
|
|
input: {
|
|
labelId: "${labelId}",
|
|
name: "${name}",
|
|
color: "${color}"
|
|
}
|
|
) {
|
|
... on UpdateLabelSuccess {
|
|
label {
|
|
id
|
|
name
|
|
color
|
|
}
|
|
}
|
|
... on UpdateLabelError {
|
|
errorCodes
|
|
}
|
|
}
|
|
}
|
|
`
|
|
})
|
|
|
|
context('when labels exists', () => {
|
|
let toUpdateLabel: Label
|
|
|
|
before(async () => {
|
|
toUpdateLabel = await createLabel('label5', '#ffffff', user.id)
|
|
labelId = toUpdateLabel.id
|
|
name = 'Updated label'
|
|
color = '#aabbcc'
|
|
})
|
|
|
|
after(async () => {
|
|
await deleteLabels({ id: toUpdateLabel.id }, user.id)
|
|
})
|
|
|
|
it('should return the updated label', async () => {
|
|
const res = await graphqlRequest(query, authToken).expect(200)
|
|
expect(res.body.data.updateLabel.label).to.eql({
|
|
id: labelId,
|
|
name,
|
|
color,
|
|
})
|
|
})
|
|
|
|
it('should update the label in db', async () => {
|
|
await graphqlRequest(query, authToken).expect(200)
|
|
const updatedLabel = await findLabelById(labelId, user.id)
|
|
|
|
expect(updatedLabel?.name).to.eql(name)
|
|
expect(updatedLabel?.color).to.eql(color)
|
|
})
|
|
|
|
context('when an item has the label', () => {
|
|
let item: LibraryItem
|
|
|
|
before(async () => {
|
|
item = await createTestLibraryItem(user.id, [toUpdateLabel])
|
|
})
|
|
|
|
after(async () => {
|
|
await deleteLibraryItemById(item.id)
|
|
})
|
|
|
|
it('should update the item with the label', async () => {
|
|
await graphqlRequest(query, authToken).expect(200)
|
|
|
|
const updatedItem = await findLibraryItemById(item.id, user.id, {
|
|
relations: {
|
|
labels: true,
|
|
},
|
|
})
|
|
const updatedLabel = updatedItem?.labels?.filter(
|
|
(l) => l.id === labelId
|
|
)?.[0]
|
|
|
|
expect(updatedLabel?.name).to.eql(name)
|
|
expect(updatedLabel?.color).to.eql(color)
|
|
})
|
|
})
|
|
})
|
|
|
|
context('when labels not exist', () => {
|
|
before(() => {
|
|
labelId = generateFakeUuid()
|
|
})
|
|
|
|
it('should return error code BAD_REQUEST', async () => {
|
|
const res = await graphqlRequest(query, authToken).expect(200)
|
|
expect(res.body.data.updateLabel.errorCodes).to.eql(['BAD_REQUEST'])
|
|
})
|
|
})
|
|
})
|
|
|
|
describe('Set labels for highlight', () => {
|
|
let query: string
|
|
let highlightId: string
|
|
let labelIds: string[] = []
|
|
let labels: Label[]
|
|
let item: LibraryItem
|
|
|
|
before(async () => {
|
|
// create testing labels
|
|
const label1 = await createLabel('label_1', '#ffffff', user.id)
|
|
const label2 = await createLabel('label_2', '#eeeeee', user.id)
|
|
labels = [label1, label2]
|
|
item = await createTestLibraryItem(user.id)
|
|
})
|
|
|
|
after(async () => {
|
|
// clean up
|
|
await deleteLabels({ user: { id: user.id } }, user.id)
|
|
await deleteLibraryItemById(item.id)
|
|
})
|
|
|
|
beforeEach(() => {
|
|
query = `
|
|
mutation {
|
|
setLabelsForHighlight(
|
|
input: {
|
|
highlightId: "${highlightId}",
|
|
labelIds: [
|
|
"${labelIds[0]}",
|
|
"${labelIds[1]}"
|
|
]
|
|
}
|
|
) {
|
|
... on SetLabelsSuccess {
|
|
labels {
|
|
id
|
|
name
|
|
}
|
|
}
|
|
... on SetLabelsError {
|
|
errorCodes
|
|
}
|
|
}
|
|
}
|
|
`
|
|
})
|
|
|
|
context('when labels exists', () => {
|
|
before(async () => {
|
|
const highlight: DeepPartial<Highlight> = {
|
|
id: highlightId,
|
|
patch: 'test patch',
|
|
quote: 'test quote',
|
|
shortId: 'test shortId 2',
|
|
user,
|
|
libraryItem: item,
|
|
}
|
|
highlightId = (await createHighlight(highlight, item.id, user.id)).id
|
|
labelIds = [labels[0].id, labels[1].id]
|
|
})
|
|
|
|
it('should set labels for highlight', async () => {
|
|
const res = await graphqlRequest(query, authToken).expect(200)
|
|
expect(
|
|
(res.body.data.setLabelsForHighlight.labels as Label[]).map(
|
|
(l) => l.id
|
|
)
|
|
).to.eql(labelIds)
|
|
})
|
|
})
|
|
|
|
context('when labels not exist', () => {
|
|
before(async () => {
|
|
const highlight: DeepPartial<Highlight> = {
|
|
patch: 'test patch',
|
|
quote: 'test quote',
|
|
shortId: 'test shortId 3',
|
|
user,
|
|
libraryItem: item,
|
|
}
|
|
highlightId = (await createHighlight(highlight, item.id, user.id)).id
|
|
labelIds = [generateFakeUuid(), generateFakeUuid()]
|
|
})
|
|
|
|
it('should return error code NOT_FOUND', async () => {
|
|
const res = await graphqlRequest(query, authToken).expect(200)
|
|
expect(res.body.data.setLabelsForHighlight.errorCodes).to.eql([
|
|
'NOT_FOUND',
|
|
])
|
|
})
|
|
})
|
|
|
|
context('when highlight not exist', () => {
|
|
before(() => {
|
|
highlightId = generateFakeUuid()
|
|
labelIds = [labels[0].id, labels[1].id]
|
|
})
|
|
|
|
it('should return error code UNAUTHORIZED', async () => {
|
|
const res = await graphqlRequest(query, authToken).expect(200)
|
|
expect(res.body.data.setLabelsForHighlight.errorCodes).to.eql([
|
|
'UNAUTHORIZED',
|
|
])
|
|
})
|
|
})
|
|
})
|
|
|
|
describe('Move label', () => {
|
|
const query = (labelId: string, afterLabelId: string): string => `
|
|
mutation {
|
|
moveLabel(
|
|
input: {
|
|
labelId: "${labelId}",
|
|
afterLabelId: "${afterLabelId}"
|
|
}
|
|
) {
|
|
... on MoveLabelSuccess {
|
|
label {
|
|
id
|
|
position
|
|
}
|
|
}
|
|
... on MoveLabelError {
|
|
errorCodes
|
|
}
|
|
}
|
|
}
|
|
`
|
|
let labelId: string
|
|
let afterLabelId: string
|
|
const labels: Label[] = []
|
|
|
|
before(async () => {
|
|
// create testing labels
|
|
for (let i = 0; i < 5; i++) {
|
|
const label = await createLabel(`label_${i}`, '#ffffff', user.id)
|
|
labels.push(label)
|
|
}
|
|
})
|
|
|
|
after(async () => {
|
|
// clean up
|
|
await deleteLabels(
|
|
labels.map((l) => l.id),
|
|
user.id
|
|
)
|
|
})
|
|
|
|
context('when label exists', () => {
|
|
before(() => {
|
|
labelId = labels[1].id
|
|
afterLabelId = labels[4].id
|
|
})
|
|
|
|
after(async () => {
|
|
await graphqlRequest(query(labelId, labels[0].id), authToken).expect(
|
|
200
|
|
)
|
|
})
|
|
|
|
it('moves label after the pointed label', async () => {
|
|
const res = await graphqlRequest(
|
|
query(labelId, afterLabelId),
|
|
authToken
|
|
).expect(200)
|
|
expect(res.body.data.moveLabel.label.position).to.eql(
|
|
labels[4].position
|
|
)
|
|
const reorderedLabels = await findLabelsByUserId(user.id)
|
|
expect(reorderedLabels.map((l) => l.id)).to.eql([
|
|
labels[0].id,
|
|
labels[2].id,
|
|
labels[3].id,
|
|
labels[4].id,
|
|
labels[1].id,
|
|
])
|
|
})
|
|
})
|
|
|
|
context('when afterLabelId is null', () => {
|
|
before(() => {
|
|
labelId = labels[4].id
|
|
})
|
|
|
|
after(async () => {
|
|
await graphqlRequest(query(labelId, labels[3].id), authToken).expect(
|
|
200
|
|
)
|
|
})
|
|
|
|
it('moves the label to the top', async () => {
|
|
const res = await graphqlRequest(query(labelId, ''), authToken).expect(
|
|
200
|
|
)
|
|
expect(res.body.data.moveLabel.label.position).to.eql(1)
|
|
})
|
|
})
|
|
|
|
context('when label not exist', () => {
|
|
before(() => {
|
|
labelId = generateFakeUuid()
|
|
})
|
|
|
|
it('returns error code NOT_FOUND', async () => {
|
|
const res = await graphqlRequest(query(labelId, ''), authToken).expect(
|
|
200
|
|
)
|
|
expect(res.body.data.moveLabel.errorCodes).to.eql(['NOT_FOUND'])
|
|
})
|
|
})
|
|
|
|
context('when after label not exist', () => {
|
|
before(() => {
|
|
labelId = labels[4].id
|
|
afterLabelId = generateFakeUuid()
|
|
})
|
|
|
|
it('returns error code NOT_FOUND', async () => {
|
|
const res = await graphqlRequest(
|
|
query(labelId, afterLabelId),
|
|
authToken
|
|
).expect(200)
|
|
expect(res.body.data.moveLabel.errorCodes).to.eql(['NOT_FOUND'])
|
|
})
|
|
})
|
|
})
|
|
})
|