custom-commands-for-cypress
Version:
Cypress custom methods
518 lines • 18.6 kB
JavaScript
;
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.generateDynamicDate = exports.generateRandomStartDate = void 0;
exports.newEmail = newEmail;
exports.newPassword = newPassword;
exports.generateRandomString = generateRandomString;
exports.extractNewOTP = extractNewOTP;
exports.getEmailWithoutDomain = getEmailWithoutDomain;
exports.readEmailOTP = readEmailOTP;
exports.getRandomNumber = getRandomNumber;
exports.generateRandomValueForKey = generateRandomValueForKey;
exports.readEmail = readEmail;
exports.readEmailContent = readEmailContent;
exports.extractOTP = extractOTP;
exports.generateRandomSpecialCharacters = generateRandomSpecialCharacters;
exports.clearSessionStorage = clearSessionStorage;
exports.writeRequest = writeRequest;
exports.generateRandomAddress = generateRandomAddress;
exports.generateRandomWebsiteLink = generateRandomWebsiteLink;
exports.hardRefresh = hardRefresh;
exports.selectRandomValueFromArray = selectRandomValueFromArray;
exports.writeEncryption = writeEncryption;
exports.generateRandomTaskName = generateRandomTaskName;
exports.formatDate = formatDate;
exports.generateFirstName = generateFirstName;
exports.generateLastName = generateLastName;
exports.generateDescription = generateDescription;
exports.readTaskRelatedEmails = readTaskRelatedEmails;
exports.generateGUID = generateGUID;
exports.readFile = readFile;
exports.sendAPIRequestWithParameters = sendAPIRequestWithParameters;
exports.APIReqWithBody = APIReqWithBody;
exports.fetchLinks = fetchLinks;
exports.extractTaskId = extractTaskId;
exports.extractEmailBody = extractEmailBody;
const axios_1 = __importDefault(require("axios"));
/// <reference types="cypress" />
const chance_1 = __importDefault(require("chance"));
const chance = new chance_1.default();
// Utility functions without Cypress dependencies
function getRandomAlphabet(length) {
const alphabet = 'abcdefghijklmnopqrstuvwxyz'; // You can include uppercase letters too if needed
let result = '';
for (let i = 0; i < length; i++) {
const randomIndex = Math.floor(Math.random() * alphabet.length);
result += alphabet[randomIndex];
}
return result;
}
function newEmail() {
const serverDomain = 'ribsoft.testinator.com';
const randomNumber = Math.floor(Math.random() * 6000) + 1;
const randomLetter = getRandomAlphabet(3);
return `automationUser_${randomLetter}${randomNumber}@${serverDomain}`;
}
function newPassword() {
const specialChars = '!@#$%^&*?';
const upperChars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
const lowerChars = 'abcdefghijklmnopqrstuvwxyz';
const numberChars = '0123456789';
let password = '';
password += specialChars.charAt(Math.floor(Math.random() * specialChars.length));
password += upperChars.charAt(Math.floor(Math.random() * upperChars.length));
password += lowerChars.charAt(Math.floor(Math.random() * lowerChars.length));
password += numberChars.charAt(Math.floor(Math.random() * numberChars.length));
const remainingChars = specialChars + upperChars + lowerChars + numberChars;
for (let i = 4; i < 8; i++) {
password += remainingChars.charAt(Math.floor(Math.random() * remainingChars.length));
}
return password;
}
function generateRandomString(length) {
let result = '';
const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
for (let i = 0; i < length; i++) {
const randomIndex = Math.floor(Math.random() * characters.length);
result += characters.charAt(randomIndex);
}
return result;
}
function generateFirstName() {
const randomFirstName = chance.first();
return randomFirstName;
}
function generateLastName() {
const randomLastName = chance.last();
return randomLastName;
}
function generateDescription() {
const randomDescription = chance.profession();
return randomDescription;
}
const generateRandomStartDate = () => {
const startDate = new Date();
startDate.setDate(startDate.getDate() + Math.floor(Math.random() * 30)); // Random date within the next 30 days
return startDate.toISOString().split('T')[0]; // Return date in YYYY-MM-DD format
};
exports.generateRandomStartDate = generateRandomStartDate;
const generateDynamicDate = () => {
const today = new Date();
// Generate a start date (current date + random offset within 30 days)
const startDate = new Date();
startDate.setDate(today.getDate() + Math.floor(Math.random() * 30));
// Generate an end date (start date + random offset within 30 days)
const endDate = new Date(startDate);
endDate.setDate(startDate.getDate() + Math.floor(Math.random() * 30) + 1);
// Format dates to YYYY-MM-DD
const formatDate = (date) => {
const year = date.getFullYear();
const month = String(date.getMonth() + 1).padStart(2, '0');
const day = String(date.getDate()).padStart(2, '0');
return `${year}-${month}-${day}`;
};
return {
startDate: formatDate(startDate),
endDate: formatDate(endDate),
};
};
exports.generateDynamicDate = generateDynamicDate;
function APIReqWithBody(http_method, req_url, req_headers, req_body, failOnStatusCode_flag) {
return (0, axios_1.default)({
method: http_method,
url: req_url,
headers: req_headers,
data: req_body,
validateStatus: function (status) {
return failOnStatusCode_flag ? status >= 200 && status < 300 : true;
},
})
.then((res) => {
return res;
})
.catch((error) => {
if (failOnStatusCode_flag) {
throw error;
}
else {
return error.response;
}
});
}
function sendAPIRequestWithParameters(failOnStatusCode_flag, http_method, req_url, req_headers, req_qs) {
return (0, axios_1.default)({
method: http_method.toUpperCase(),
url: req_url,
headers: req_headers,
params: req_qs,
validateStatus: function (status) {
return failOnStatusCode_flag ? status >= 200 && status < 300 : true;
},
})
.then((res) => {
return res;
})
.catch((error) => {
if (failOnStatusCode_flag) {
throw error;
}
else {
return error.response;
}
});
}
function getRandomNumber(digits) {
var min = Math.pow(10, digits - 1);
var max = Math.pow(10, digits) - 1;
return Math.floor(Math.random() * (max - min + 1)) + min;
}
function readFile(filepath) {
return new Promise((resolve) => {
cy.readFile(filepath).then((data) => {
//console.log(data);
resolve(data);
});
});
}
function generateGUID() {
function s4() {
return Math.floor((1 + Math.random()) * 0x10000)
.toString(16)
.substring(1);
}
return (s4() +
s4() +
'-' +
s4() +
'-' +
s4() +
'-' +
s4() +
'-' +
s4() +
s4() +
s4());
}
function readEmailOTP(emailAddress, emailSubject, token, domain) {
const trimmedEmail = getEmailWithoutDomain(emailAddress);
console.log(trimmedEmail);
return axios_1.default
.get(`https://mailinator.com/api/v2/domains/${domain}/inboxes/${trimmedEmail}/?token=${token}`)
.then((response) => {
const emails = response.data.msgs;
console.log("Emails:", emails);
// Find the email with the matching subject
const email = emails.find((msg) => msg.subject === emailSubject);
if (email) {
const messageId = email.id;
console.log("Message ID:", messageId);
return axios_1.default.get(`https://mailinator.com/api/v2/domains/${domain}/messages/${messageId}?token=${token}`);
}
else {
throw new Error(`Email not found for address: ${trimmedEmail}`);
}
})
.then((response) => {
const emailresponse = response;
console.log("third", emailresponse);
const emailContent = response.data.parts[0].body;
const otp = extractNewOTP(emailContent);
return otp;
});
}
function fetchLinks(emailSubject, token, domain) {
return axios_1.default
.get(`https://mailinator.com/api/v2/domains/${domain}/inboxes/:*/?token=${token}`)
.then((response) => {
const emails = response.data.msgs;
const email = emails.find((msg) => msg.subject.includes(emailSubject) || msg.from.includes(emailSubject));
if (email) {
const messageId = email.id;
return axios_1.default.get(`https://mailinator.com/api/v2/domains/${domain}/messages/${messageId}/links?token=${token}`);
}
else {
throw new Error("Email not found");
}
})
.then((linksResponse) => {
return linksResponse.data.links; // Return the links directly
})
.catch((error) => {
console.error("Error retrieving links:", error);
throw error; // Re-throw the error to be caught by the caller
});
}
function generateRandomValueForKey(length) {
let result = "";
for (let i = 0; i < length; i++) {
const randomCharCode = Math.floor(Math.random() * 26) + 97; // Generate random ASCII code for lowercase letters (97-122)
const randomCharacter = String.fromCharCode(randomCharCode);
result += randomCharacter;
}
return result;
}
function readEmail(emailAddress, token, domain) {
// Encode email address to be used in the API request
const encodedEmailAddress = encodeURIComponent(emailAddress);
return axios_1.default
.get(`https://mailinator.com/api/v2/domains/${domain}/inboxes/${encodedEmailAddress}/?token=${token}`)
.then((response) => {
const emails = response.data.msgs;
const email = emails[0]; // Assuming you want the latest email
if (email) {
const messageId = email.id;
return axios_1.default.get(`https://mailinator.com/api/v2/domains/${domain}/messages/${messageId}?token=${token}`);
}
else {
throw new Error(`Email not found for address: ${emailAddress}`);
}
})
.then((response) => {
const emailresponse = response;
return { emailresponse };
});
}
function readEmailContent(emailSubject, token, domain) {
return axios_1.default
.get(`https://mailinator.com/api/v2/domains/${domain}/inboxes/:*/?token=${token}`)
.then((response) => {
const emails = response.data.msgs;
const email = emails.find((msg) => {
return msg.subject.includes(emailSubject) || msg.from.includes(emailSubject);
});
if (email) {
const messageId = email.id;
return axios_1.default.get(`https://mailinator.com/api/v2/domains/${domain}/messages/${messageId}?token=${token}`);
;
}
else {
throw new Error("Email not found");
}
})
.then((response) => {
const emailContent = response.data.parts[0].body;
const otp = extractOTP(emailContent);
return otp;
});
}
function extractOTP(emailContent) {
const otpPattern = /([0-9]{6})/;
const match = otpPattern.exec(emailContent);
if (match) {
return match[1];
}
else {
return null;
}
}
function extractEmailBody(emailContent) {
const emailWithoutLinks = emailContent.replace(/<a\b[^>]*>(.*?)<\/a>/gi, '');
const htmlTagsPattern = /<[^>]*>/g;
const textOnly = emailWithoutLinks.replace(htmlTagsPattern, '');
//const textOnly = emailContent.replace(htmlTagsPattern, '');
// Trim spaces from the extracted text (remove spaces from the beginning and end)
const trimmedText = textOnly.trim();
// Remove any periods (.) at the end of the text
const textWithoutPeriod = trimmedText.replace(/\.$/, '');
return textWithoutPeriod;
}
function readTaskRelatedEmails(emailAddress, emailSubject, token, domain) {
const trimmedEmail = getEmailWithoutDomain(emailAddress);
console.log(trimmedEmail);
return axios_1.default
.get(`https://mailinator.com/api/v2/domains/${domain}/inboxes/${trimmedEmail}/?token=${token}`)
.then((response) => {
const emails = response.data.msgs;
console.log("Emails:", emails);
// Find the email with the matching subject
const email = emails.find((msg) => msg.subject && msg.subject.includes(emailSubject));
if (email) {
const messageId = email.id;
console.log("Message ID:", messageId);
return axios_1.default.get(`https://mailinator.com/api/v2/domains/${domain}/messages/${messageId}?token=${token}`);
}
else {
throw new Error(`Email not found for address: ${trimmedEmail}`);
}
})
.then((response) => {
const emailresponse = response;
console.log("Email response contains: ", emailresponse);
const emailContent = response.data.parts[0].body;
const taskId = extractTaskId(emailContent);
return taskId;
});
}
function getEmailWithoutDomain(email1) {
const atIndex = email1.indexOf('@');
if (atIndex !== -1) {
return email1.substring(0, atIndex);
}
return email1;
}
function extractNewOTP(emailContent) {
const otpPattern = /<center>\s*<h2>(\d{6})<\/h2>\s*<\/center>/i;
const match = otpPattern.exec(emailContent);
if (match) {
return match[1];
}
else {
return null;
}
}
function extractTaskId(emailContent) {
const IdPattern = /\[#([A-Z0-9]+)\]/;
const match = IdPattern.exec(emailContent);
if (match) {
return match[1];
}
else {
return null;
}
}
function generateRandomSpecialCharacters(length) {
const specialChars = "!@#$%^&*()_-+=[]{}|;:,.<>?";
let randomString = '';
for (let i = 0; i < length; i++) {
const randomIndex = Math.floor(Math.random() * specialChars.length);
randomString += specialChars.charAt(randomIndex);
}
return randomString;
}
function clearSessionStorage() {
cy.clearAllSessionStorage().then(() => {
cy.clearAllCookies;
cy.clearAllLocalStorage;
cy.window().should((win) => {
win.sessionStorage.clear();
expect(Object.keys(win.sessionStorage).length).to.equal(0);
console.log('SessionStorage cleared.', win.sessionStorage);
});
}).then(() => {
cy.wait(1000);
});
}
function writeRequest(path, request) {
const filePath = path;
const getRequestArray = [];
getRequestArray.push(request);
const jsonData = JSON.stringify(getRequestArray, null, 2);
cy.writeFile(filePath, jsonData).then(() => {
console.log("Request updated successfully.");
});
}
function generateRandomAddress() {
const addressData = [
{
street: 'Wall Street',
state: 'New York',
city: 'New York City',
zipCode: '10005',
country: 'United States'
},
{
street: 'Queen Street',
state: 'Ontario',
city: 'Toronto',
zipCode: '53462',
country: 'Canada'
},
{
street: 'Zhongshan Road',
state: 'Guangdong',
city: 'Guangzhou',
zipCode: '510055',
country: 'China'
},
];
const randomAddress = addressData[Math.floor(Math.random() * addressData.length)];
const addressLine1 = `${randomAddress.street}, ${randomAddress.city}, ${randomAddress.state}, ${randomAddress.zipCode}`;
return {
addressLine1,
state: randomAddress.state,
city: randomAddress.city,
zipCode: randomAddress.zipCode,
country: randomAddress.country
};
}
function generateRandomWebsiteLink() {
const protocol = 'https://';
const domain = generateFirstName(); // Assuming this function generates a random string of given length
const tld = '.com';
const randomLink = `${protocol}${domain}${tld}`;
return randomLink;
}
function hardRefresh() {
cy.reload(true);
cy.wait(1000);
}
function selectRandomValueFromArray(arr) {
return arr[Math.floor(Math.random() * arr.length)];
}
;
function writeEncryption(email, password, file_Path) {
const filePath = file_Path;
const getSenderArray = [];
const dataToWrite = {
email: email,
password: password
};
getSenderArray.push(dataToWrite);
const jsonData = JSON.stringify(getSenderArray, null, 2);
cy.writeFile(filePath, jsonData).then(() => {
console.log("Encrypt Email and Password updated successfully");
});
cy.wait(2000);
}
function generateRandomTaskName() {
const keywords = [
"Architectural Design",
"Structural Engineering",
"Site Inspection",
"Material Procurement",
"Building Information Modeling (BIM)",
"Construction Safety Plan",
"Urban Planning Strategy",
"HVAC System Installation",
"Electrical Wiring Layout",
"Plumbing Blueprint",
"Environmental Impact Assessment",
"Concrete Foundation Pouring",
"Steel Reinforcement Placement",
"Project Milestone Review",
"Contractor Coordination",
"Building Code Compliance",
"Subcontractor Selection",
"Risk Assessment",
"Quality Assurance Check",
"LEED Certification Review",
"Cost Estimation",
"3D Rendering Approval",
"Permit Acquisition",
"Feasibility Study Report",
"Floor Plan Design",
"Site Survey and Grading",
"Energy Efficiency Analysis"
];
// Generate a random task name by joining a few random keywords
let taskName = '';
while (taskName.length < 50) {
const randomKeyword = keywords[Math.floor(Math.random() * keywords.length)];
if (taskName.length + randomKeyword.length + 1 <= 150) {
taskName += taskName.length > 0 ? ` - ${randomKeyword}` : randomKeyword;
}
else {
break;
}
}
return taskName;
}
function formatDate(dateString) {
const [year, month, day] = dateString.split('-');
return `${day}-${month}-${year}`;
}
;
//# sourceMappingURL=commonMethods.js.map