732 lines
19 KiB
TypeScript
732 lines
19 KiB
TypeScript
import { arrayBufferToBase64 } from './../util/helper-functions'
|
|
import * as moment from 'moment'
|
|
|
|
const username = Cypress.env('username')
|
|
const password = Cypress.env('password')
|
|
const hostUrl = Cypress.env('hosturl')
|
|
const appLocation = Cypress.env('appLocation')
|
|
const longerCommandTimeout = Cypress.env('longerCommandTimeout')
|
|
const fixturePath = 'excels_general/'
|
|
const serverType = Cypress.env('serverType')
|
|
const site_id = Cypress.env(`site_id_${serverType}`)
|
|
const libraryToOpenIncludes = Cypress.env(`libraryToOpenIncludes_${serverType}`)
|
|
const testLicenceUserLimits = Cypress.env('testLicenceUserLimits')
|
|
|
|
/** IMPORTANT NOTICE
|
|
* Before running tests, make sure that table `MPE_USERS` is present
|
|
*/
|
|
|
|
interface EditConfigTableCells {
|
|
varName: string
|
|
varValue: string
|
|
}
|
|
|
|
context('licensing tests: ', function () {
|
|
this.beforeAll(() => {
|
|
// cy.visit(`${hostUrl}/SASLogon/logout`)
|
|
cy.loginAndUpdateValidKey()
|
|
})
|
|
|
|
this.beforeEach(() => {
|
|
cy.visit(hostUrl + appLocation)
|
|
// cy.get('input.username').type(username)
|
|
// cy.get('input.password').type(password)
|
|
// cy.get('.login-group button').click()
|
|
|
|
visitPage('home')
|
|
})
|
|
|
|
it('1 | key valid, not expired', (done) => {
|
|
let keyData = {
|
|
valid_until: moment().add(1, 'year').format('YYYY-MM-DD'),
|
|
users_allowed: 4,
|
|
hot_license_key: '',
|
|
demo: false,
|
|
site_id: site_id
|
|
}
|
|
|
|
let keys: { licenseKey: any; activationKey: any }
|
|
generateKeys(keyData, (keysGen: any) => {
|
|
keys = keysGen
|
|
|
|
cy.wait(2000)
|
|
|
|
isLicensingPage((result: boolean) => {
|
|
if (result) {
|
|
inputLicenseKeyPage(keys.licenseKey, keys.activationKey)
|
|
|
|
cy.wait(2000)
|
|
}
|
|
|
|
acceptTermsIfPresented((result: boolean) => {
|
|
if (result) {
|
|
cy.wait(10000)
|
|
}
|
|
|
|
visitPage('home')
|
|
|
|
cy.get('.nav-tree clr-tree > clr-tree-node', {
|
|
timeout: longerCommandTimeout
|
|
}).then((treeNodes: any) => {
|
|
done()
|
|
})
|
|
})
|
|
})
|
|
})
|
|
})
|
|
|
|
it('2 | Key will expire in less then 14 days, not free tier', (done) => {
|
|
// make 2 separate for this one
|
|
let keyData = {
|
|
valid_until: moment().add(10, 'day').format('YYYY-MM-DD'),
|
|
users_allowed: 4,
|
|
hot_license_key: '',
|
|
demo: false,
|
|
site_id: site_id
|
|
}
|
|
|
|
let keys: { licenseKey: any; activationKey: any }
|
|
generateKeys(keyData, (keysGen: any) => {
|
|
keys = keysGen
|
|
console.log('keys', keys)
|
|
|
|
cy.wait(2000)
|
|
|
|
acceptTermsIfPresented((result: boolean) => {
|
|
if (result) {
|
|
cy.wait(20000)
|
|
}
|
|
updateLicenseKeyQuick(keysGen, () => {
|
|
cy.wait(2000)
|
|
acceptTermsIfPresented((result: boolean) => {
|
|
if (result) {
|
|
cy.wait(20000)
|
|
}
|
|
verifyLicensingWarning('This license key will expire in ', () => {
|
|
done()
|
|
})
|
|
})
|
|
})
|
|
})
|
|
})
|
|
})
|
|
|
|
it('3 | key expired, free tier works', (done) => {
|
|
let keyData = {
|
|
valid_until: moment().subtract(1, 'day').format('YYYY-MM-DD'),
|
|
users_allowed: 4,
|
|
hot_license_key: '',
|
|
demo: false,
|
|
site_id: site_id
|
|
}
|
|
|
|
let keys: { licenseKey: any; activationKey: any }
|
|
generateKeys(keyData, (keysGen: any) => {
|
|
keys = keysGen
|
|
|
|
cy.wait(2000)
|
|
|
|
acceptTermsIfPresented((result: boolean) => {
|
|
if (result) {
|
|
cy.wait(20000)
|
|
}
|
|
cy.wait(2000)
|
|
updateLicenseKeyQuick(keysGen, () => {
|
|
cy.wait(2000)
|
|
acceptTermsIfPresented((result: boolean) => {
|
|
if (result) {
|
|
cy.wait(20000)
|
|
}
|
|
verifyLicensingPage(
|
|
'Licence key is expired - please contact',
|
|
(success: boolean) => {
|
|
if (success) {
|
|
verifyLicensingWarning(
|
|
'(FREE Tier) - Problem with licence',
|
|
() => {
|
|
done()
|
|
}
|
|
)
|
|
}
|
|
}
|
|
)
|
|
})
|
|
})
|
|
})
|
|
})
|
|
})
|
|
|
|
it('4 | key invalid, free tier works', (done) => {
|
|
let keyData = {
|
|
valid_until: moment().subtract(1, 'day').format('YYYY-MM-DD'),
|
|
users_allowed: 4,
|
|
hot_license_key: '',
|
|
demo: false,
|
|
site_id: site_id
|
|
}
|
|
|
|
let keys: { licenseKey: any; activationKey: any }
|
|
generateKeys(keyData, (keysGen: any) => {
|
|
keys = keysGen
|
|
keys.activationKey = 'invalid' + keys.activationKey
|
|
|
|
cy.wait(2000)
|
|
|
|
acceptTermsIfPresented((result: boolean) => {
|
|
if (result) {
|
|
cy.wait(20000)
|
|
}
|
|
cy.wait(2000)
|
|
updateLicenseKeyQuick(keysGen, () => {
|
|
cy.wait(2000)
|
|
acceptTermsIfPresented((result: boolean) => {
|
|
if (result) {
|
|
cy.wait(20000)
|
|
}
|
|
verifyLicensingPage(
|
|
'Licence key is invalid - please contact',
|
|
(success: boolean) => {
|
|
if (success) {
|
|
verifyLicensingWarning(
|
|
'(FREE Tier) - Problem with licence',
|
|
() => {
|
|
done()
|
|
}
|
|
)
|
|
}
|
|
}
|
|
)
|
|
})
|
|
})
|
|
})
|
|
})
|
|
})
|
|
|
|
it('5 | key for wrong organisation, free tier works', (done) => {
|
|
let keyData = {
|
|
valid_until: moment().add(1, 'year').format('YYYY-MM-DD'),
|
|
users_allowed: 4,
|
|
hot_license_key: '',
|
|
demo: false,
|
|
site_id: 100
|
|
}
|
|
|
|
let keys: { licenseKey: any; activationKey: any }
|
|
generateKeys(keyData, (keysGen: any) => {
|
|
keys = keysGen
|
|
keys.activationKey = keys.activationKey
|
|
|
|
cy.wait(2000)
|
|
|
|
acceptTermsIfPresented((result: boolean) => {
|
|
if (result) {
|
|
cy.wait(20000)
|
|
}
|
|
cy.wait(2000)
|
|
updateLicenseKeyQuick(keysGen, () => {
|
|
cy.wait(2000)
|
|
acceptTermsIfPresented((result: boolean) => {
|
|
if (result) {
|
|
cy.wait(20000)
|
|
}
|
|
verifyLicensingPage(
|
|
'SYSSITE (below) is not found',
|
|
(success: boolean) => {
|
|
if (success) {
|
|
verifyLicensingWarning(
|
|
'(FREE Tier) - Problem with licence',
|
|
() => {
|
|
done()
|
|
}
|
|
)
|
|
}
|
|
}
|
|
)
|
|
})
|
|
})
|
|
})
|
|
})
|
|
})
|
|
|
|
if (testLicenceUserLimits) {
|
|
it('4 | User try to register when limit is reached', (done) => {
|
|
let keyData = {
|
|
valid_until: moment().add(1, 'month').format('YYYY-MM-DD'),
|
|
users_allowed: 10,
|
|
hot_license_key: '',
|
|
demo: false,
|
|
site_id: site_id
|
|
}
|
|
let keyData2 = {
|
|
valid_until: moment().add(1, 'month').format('YYYY-MM-DD'),
|
|
users_allowed: 1,
|
|
hot_license_key: '',
|
|
demo: false,
|
|
site_id: site_id
|
|
}
|
|
generateKeys(keyData, (keysGen: any) => {
|
|
generateKeys(keyData2, (keysGen2: any) => {
|
|
cy.wait(2000)
|
|
|
|
acceptTermsIfPresented((result: boolean) => {
|
|
if (result) {
|
|
cy.wait(20000)
|
|
}
|
|
updateLicenseKeyQuick(keysGen, () => {
|
|
cy.wait(2000)
|
|
acceptTermsIfPresented((result: boolean) => {
|
|
if (result) {
|
|
cy.wait(20000)
|
|
}
|
|
|
|
updateLicenseKeyQuick(keysGen2, () => {
|
|
cy.wait(2000)
|
|
|
|
const random = Cypress._.random(0, 1000)
|
|
const newUser = {
|
|
username: `randomusername${random}notregistered`,
|
|
last_seen_at: moment().add(1, 'month').format('YYYY-MM-DD'),
|
|
registered_at: moment().add(1, 'month').format('YYYY-MM-DD')
|
|
}
|
|
updateUsersTable(
|
|
{ deleteAll: true, newUsers: [newUser] },
|
|
() => {
|
|
logout(() => {
|
|
cy.visit(hostUrl + appLocation)
|
|
// cy.get('input.username').type(username)
|
|
// cy.get('input.password').type(password)
|
|
// cy.get('.login-group button').click()
|
|
|
|
visitPage('home')
|
|
|
|
cy.wait(2000)
|
|
|
|
verifyLicensingPage(
|
|
'The registered number of users reached the limit specified for your licence.',
|
|
(success: boolean) => {
|
|
if (success) done()
|
|
}
|
|
)
|
|
})
|
|
}
|
|
)
|
|
})
|
|
})
|
|
})
|
|
})
|
|
})
|
|
})
|
|
})
|
|
|
|
it('5 | Show warning banner when limit is exceeded', (done) => {
|
|
let keyData = {
|
|
valid_until: moment().add(1, 'month').format('YYYY-MM-DD'),
|
|
users_allowed: 10,
|
|
hot_license_key: '',
|
|
demo: false,
|
|
site_id: site_id
|
|
}
|
|
let keyData2 = {
|
|
valid_until: moment().add(1, 'month').format('YYYY-MM-DD'),
|
|
users_allowed: 1,
|
|
hot_license_key: '',
|
|
demo: false,
|
|
site_id: site_id
|
|
}
|
|
|
|
generateKeys(keyData, (keysGen: any) => {
|
|
generateKeys(keyData2, (keysGen2: any) => {
|
|
cy.wait(2000)
|
|
acceptTermsIfPresented((result: boolean) => {
|
|
if (result) {
|
|
cy.wait(20000)
|
|
}
|
|
updateLicenseKeyQuick(keysGen, () => {
|
|
cy.wait(2000)
|
|
acceptTermsIfPresented((result: boolean) => {
|
|
if (result) {
|
|
cy.wait(20000)
|
|
}
|
|
const random = Cypress._.random(0, 1000)
|
|
const newUser = {
|
|
username: `randomusername${random}`,
|
|
last_seen_at: moment().add(1, 'month').format('YYYY-MM-DD'),
|
|
registered_at: moment().add(1, 'month').format('YYYY-MM-DD')
|
|
}
|
|
updateUsersTable(
|
|
{ deleteAll: true, keep: username, newUsers: [newUser] },
|
|
() => {
|
|
updateLicenseKeyQuick(keysGen2, () => {
|
|
cy.wait(2000)
|
|
verifyLicensingWarning(
|
|
'The registered number of users exceeds the limit specified for your license.',
|
|
() => {
|
|
done()
|
|
}
|
|
)
|
|
})
|
|
}
|
|
)
|
|
})
|
|
})
|
|
})
|
|
})
|
|
})
|
|
})
|
|
}
|
|
|
|
this.afterEach(() => {
|
|
// cy.visit(`${hostUrl}/SASLogon/logout`)
|
|
})
|
|
})
|
|
|
|
const logout = (callback?: any) => {
|
|
cy.get('.header-actions .dropdown-toggle')
|
|
.click()
|
|
.then(() => {
|
|
cy.get('.header-actions .dropdown-menu > .separator')
|
|
.next()
|
|
.click()
|
|
.then(() => {
|
|
if (callback) callback()
|
|
})
|
|
})
|
|
}
|
|
|
|
const acceptTermsIfPresented = (callback?: any) => {
|
|
cy.url().then((url: string) => {
|
|
if (url.includes('licensing/register')) {
|
|
cy.get('.card-block')
|
|
.scrollTo('bottom')
|
|
.then(() => {
|
|
cy.get('#checkbox1')
|
|
.click()
|
|
.then(() => {
|
|
if (callback) callback(true)
|
|
})
|
|
})
|
|
} else {
|
|
if (callback) callback(false)
|
|
}
|
|
})
|
|
}
|
|
|
|
const isLicensingPage = (callback: any) => {
|
|
return cy.url().then((url: string) => {
|
|
callback(
|
|
url.includes('#/licensing/') && !url.includes('licensing/register')
|
|
)
|
|
})
|
|
}
|
|
|
|
const verifyLicensingPage = (text: string, callback: any) => {
|
|
// visitPage('home')
|
|
|
|
cy.wait(1000)
|
|
isLicensingPage((result: boolean) => {
|
|
if (result) {
|
|
cy.get('p.key-error')
|
|
.should('contain', text)
|
|
.then((treeNodes: any) => {
|
|
callback(true)
|
|
})
|
|
}
|
|
})
|
|
}
|
|
|
|
const verifyLicensingWarning = (text: string, callback: any) => {
|
|
visitPage('home')
|
|
|
|
cy.wait(1000)
|
|
cy.get("div[role='alert'] .alert-text")
|
|
.invoke('text')
|
|
.should('contain', text)
|
|
.then(() => {
|
|
callback()
|
|
})
|
|
}
|
|
|
|
const inputLicenseKeyPage = (licenseKey: string, activationKey: string) => {
|
|
cy.get('button').contains('Paste licence').click()
|
|
|
|
cy.get('.license-key-form textarea', { timeout: longerCommandTimeout })
|
|
.invoke('val', licenseKey)
|
|
.trigger('input')
|
|
.should('not.be.undefined')
|
|
cy.get('.activation-key-form textarea', { timeout: longerCommandTimeout })
|
|
.invoke('val', activationKey)
|
|
.trigger('input')
|
|
.should('not.be.undefined')
|
|
cy.get('button.apply-keys').click()
|
|
}
|
|
|
|
const updateUsersTable = (options: any, callback?: any) => {
|
|
visitPage('home')
|
|
openTableFromTree(libraryToOpenIncludes, 'mpe_users')
|
|
|
|
clickOnEdit(() => {
|
|
cy.get('.ht_master tbody tr').then((rows: any) => {
|
|
if (options.deleteAll) {
|
|
for (let row of rows) {
|
|
const user_id = row.childNodes[2]
|
|
if (!options.keep || user_id.innerText !== options.keep) {
|
|
cy.get(row.childNodes[1])
|
|
.dblclick()
|
|
.then(() => {
|
|
cy.focused().type('{selectall}').type('Yes').type('{enter}')
|
|
})
|
|
}
|
|
}
|
|
}
|
|
if (options.newUsers && options.newUsers.length) {
|
|
for (let newUser of options.newUsers) {
|
|
clickOnAddRow(() => {
|
|
cy.get('#hotInstance tbody tr:last-child').then((rows: any) => {
|
|
cy.get(rows[0].childNodes[2])
|
|
.dblclick()
|
|
.then(() => {
|
|
cy.focused()
|
|
.type('{selectall}')
|
|
.type(newUser.username)
|
|
.type('{enter}')
|
|
})
|
|
// cy.get(rows[0].childNodes[3])
|
|
// .dblclick()
|
|
// .then(() => {
|
|
// cy.focused()
|
|
// .type('{selectall}')
|
|
// .type(newUser.last_seen_at)
|
|
// .type('{enter}')
|
|
// })
|
|
// cy.get(rows[0].childNodes[4])
|
|
// .dblclick()
|
|
// .then(() => {
|
|
// cy.focused()
|
|
// .type('{selectall}')
|
|
// .type(newUser.registered_at)
|
|
// .type('{enter}')
|
|
// })
|
|
submitTable(() => {
|
|
cy.wait(2000)
|
|
approveTable(callback)
|
|
})
|
|
})
|
|
})
|
|
}
|
|
}
|
|
})
|
|
})
|
|
}
|
|
|
|
const changeLicenseKeyTable = (keys: any, callback?: any) => {
|
|
visitPage('home')
|
|
openTableFromTree(libraryToOpenIncludes, 'mpe_config')
|
|
|
|
clickOnEdit(() => {
|
|
editTableField(
|
|
[
|
|
{ varName: 'DC_ACTIVATION_KEY', varValue: keys.activationKey },
|
|
{ varName: 'DC_LICENCE_KEY', varValue: keys.licenseKey }
|
|
],
|
|
() => {
|
|
submitTable(() => {
|
|
cy.wait(2000)
|
|
approveTable(() => {
|
|
cy.reload()
|
|
if (callback) callback()
|
|
})
|
|
})
|
|
}
|
|
)
|
|
})
|
|
}
|
|
|
|
const updateLicenseKeyQuick = (keys: any, callback: any) => {
|
|
isLicensingPage((result: boolean) => {
|
|
if (!result) {
|
|
visitPage('licensing/update')
|
|
cy.wait(2000)
|
|
}
|
|
inputLicenseKeyPage(keys.licenseKey, keys.activationKey)
|
|
|
|
callback()
|
|
})
|
|
}
|
|
|
|
const generateKeys = async (licenseData: any, resultCallback?: any) => {
|
|
let keyPair = await window.crypto.subtle.generateKey(
|
|
{
|
|
name: 'RSA-OAEP',
|
|
modulusLength: 2024,
|
|
publicExponent: new Uint8Array([1, 0, 1]),
|
|
hash: 'SHA-256'
|
|
},
|
|
true,
|
|
['encrypt', 'decrypt']
|
|
)
|
|
|
|
const encoded = new TextEncoder().encode(JSON.stringify(licenseData))
|
|
|
|
const cipher = await window.crypto.subtle
|
|
.encrypt(
|
|
{
|
|
name: 'RSA-OAEP'
|
|
},
|
|
keyPair.publicKey,
|
|
encoded
|
|
)
|
|
.then(
|
|
(value) => {
|
|
return value
|
|
},
|
|
(err) => {
|
|
console.log('Encrpyt error', err)
|
|
}
|
|
)
|
|
|
|
if (!cipher) {
|
|
alert('Encryptin keys failed')
|
|
throw new Error('Encryptin keys failed')
|
|
}
|
|
|
|
const privateKeyBytes = await window.crypto.subtle.exportKey(
|
|
'pkcs8',
|
|
keyPair.privateKey
|
|
)
|
|
|
|
const activationKey = await arrayBufferToBase64(privateKeyBytes)
|
|
const licenseKey = await arrayBufferToBase64(cipher)
|
|
|
|
if (resultCallback)
|
|
resultCallback({
|
|
activationKey,
|
|
licenseKey
|
|
})
|
|
}
|
|
|
|
const editTableField = (edits: EditConfigTableCells[], callback?: any) => {
|
|
cy.get('td').then((tdNodes: any) => {
|
|
for (let edit of edits) {
|
|
let correctRow = false
|
|
|
|
for (let node of tdNodes) {
|
|
if (correctRow) {
|
|
cy.get(node)
|
|
.dblclick()
|
|
.then(() => {
|
|
// textarea update on long keys
|
|
cy.focused().invoke('val', edit.varValue).type('{enter}')
|
|
})
|
|
|
|
correctRow = false
|
|
break
|
|
}
|
|
|
|
if (node.innerText.includes(edit.varName)) {
|
|
correctRow = true
|
|
}
|
|
}
|
|
}
|
|
|
|
if (callback) callback()
|
|
})
|
|
}
|
|
|
|
const openTableFromTree = (
|
|
libNameIncludes: string,
|
|
tablename: string,
|
|
callback?: any
|
|
) => {
|
|
cy.get('.app-loading', { timeout: longerCommandTimeout })
|
|
.should('not.exist')
|
|
.then(() => {
|
|
cy.get('.nav-tree clr-tree > clr-tree-node', {
|
|
timeout: longerCommandTimeout
|
|
}).then((treeNodes: any) => {
|
|
let viyaLib
|
|
|
|
for (let node of treeNodes) {
|
|
if (node.innerText.toLowerCase().includes(libNameIncludes)) {
|
|
viyaLib = node
|
|
break
|
|
}
|
|
}
|
|
|
|
cy.get(viyaLib).within(() => {
|
|
cy.get('.clr-tree-node-content-container > button').click()
|
|
|
|
cy.get('.clr-treenode-link').then((innerNodes: any) => {
|
|
for (let innerNode of innerNodes) {
|
|
if (innerNode.innerText.toLowerCase().includes(tablename)) {
|
|
innerNode.click()
|
|
if (callback) callback()
|
|
break
|
|
}
|
|
}
|
|
})
|
|
})
|
|
})
|
|
})
|
|
}
|
|
|
|
const clickOnAddRow = (callback?: any) => {
|
|
cy.get('.btnCtrl button.btn-success')
|
|
.click()
|
|
.then(() => {
|
|
if (callback) callback()
|
|
})
|
|
}
|
|
|
|
const clickOnEdit = (callback?: any) => {
|
|
cy.get('.btnCtrl button.btn-primary', { timeout: longerCommandTimeout })
|
|
.click()
|
|
.then(() => {
|
|
if (callback) callback()
|
|
})
|
|
}
|
|
|
|
const submitTable = (callback?: any) => {
|
|
cy.get('.btnCtrl button.btn-primary', { timout: longerCommandTimeout })
|
|
.click()
|
|
.then(() => {
|
|
cy.get(".modal.ng-star-inserted button[type='submit']")
|
|
.click()
|
|
.then(() => {
|
|
if (callback) callback()
|
|
})
|
|
})
|
|
}
|
|
|
|
const approveTable = (callback?: any) => {
|
|
cy.get('button', { timeout: longerCommandTimeout })
|
|
.should('contain', 'Go to approvals screen')
|
|
.then((allButtons: any) => {
|
|
for (let approvalButton of allButtons) {
|
|
if (
|
|
approvalButton.innerText
|
|
.toLowerCase()
|
|
.includes('go to approvals screen')
|
|
) {
|
|
approvalButton.click()
|
|
break
|
|
}
|
|
}
|
|
|
|
cy.get('button#acceptBtn', { timeout: longerCommandTimeout })
|
|
.should('exist')
|
|
.should('not.be.disabled')
|
|
.click()
|
|
.then(() => {
|
|
cy.get('app-history', { timeout: longerCommandTimeout })
|
|
.should('exist')
|
|
.then(() => {
|
|
if (callback) callback()
|
|
})
|
|
})
|
|
})
|
|
}
|
|
|
|
const visitPage = (url: string) => {
|
|
cy.visit(`${hostUrl}${appLocation}/#/${url}`)
|
|
}
|