DEV Community: Dennis Zhang

Jenkins Pipeline

Dennis Zhang — Tue, 19 Nov 2024 07:27:25 +0000

pipeline {
    agent any

    environment {
        // 假设生成的文件名会以时间戳为基础
        REPORT_PATH = "report/build_report_${env.BUILD_ID}.html"  // 动态生成文件名
    }

    stages {
        stage('Build') {
            steps {
                script {
                    // 使用动态生成的文件路径生成报告
                    sh "echo 'Build report content' > ${env.REPORT_PATH}"
                    echo "Report generated at: ${env.REPORT_PATH}"
                }
            }
        }
 stage('Archive') {
            steps {
                // 归档构建过程中生成的文件
                archiveArtifacts artifacts: 'build/output.zip', allowEmptyArchive: true
            }
        }
        stage('Check Report Existence') {
            steps {
                script {
                    // 检查动态生成的报告文件是否存在
                    def fileExists = sh(script: "test -f ${env.REPORT_PATH} && echo 'yes' || echo 'no'", returnStdout: true).trim()

                    if (fileExists == "yes") {
                        echo "Report file exists at: ${env.REPORT_PATH}. Proceeding to send email."
                    } else {
                        error "Report file does not exist at: ${env.REPORT_PATH}. Aborting email sending."
                    }
                }
            }
        }

        stage('Send Email') {
            steps {
                script {
                    // 使用动态路径发送邮件
                    def fileExists = sh(script: "test -f ${env.REPORT_PATH} && echo 'yes' || echo 'no'", returnStdout: true).trim()

                    if (fileExists == "yes") {
                        emailext (
                            subject: "Build Report - ${env.BUILD_ID}",
                            body: "Please find the attached build report.",
                            attachmentsPattern: "${env.REPORT_PATH}"  // 使用动态路径
                        )
                    } else {
                        echo "Report file not found, skipping email sending."
                    }
                }
            }
        }
    }
}

解析feature和csv文件插件

Dennis Zhang — Mon, 04 Nov 2024 08:50:41 +0000

npm i gherkin-parse csv-parse

const parse = require("gherkin-parse")
const fs = require("fs")

const jsonObject = parse.convertFeatureFileToJson(featurePath)

const featureString = parse.convertJSONToFeatureFile(jsonObject)// 没有包含comment

const comment =jsonObject.comments.map(item=>item.text).join("\n")

// update feature file
fs.writeFileSync(featurePath,`${featureString}\n\n\n${comment}` )

Jmeter变量

Dennis Zhang — Fri, 18 Oct 2024 09:22:33 +0000

循环次数变量
${counter(TRUE,)}
TRUE：表示该计数器是基于每个线程独立的，即每个线程会分别计数。
${threadNum}
来获取线程编号

node 创建目录

Dennis Zhang — Mon, 07 Oct 2024 06:12:12 +0000

// 异步
const fs = require('fs');

fs.mkdir('my-directory', { recursive: true }, (err) => {
  if (err) {
    return console.error('Error creating directory:', err);
  }
  console.log('Directory created successfully!');
});
// 同步
const fs = require('fs');

try {
  fs.mkdirSync('my-directory', { recursive: true });
  console.log('Directory created successfully!');
} catch (err) {
  console.error('Error creating directory:', err);
}

// 写入文件的最终方案
const fs = require('fs');
const path = require('path');

// 要写入文件的路径拼接系统路径/或者\
const filePath = path.join('path', 'to', 'directory', 'file.txt');

// 获取文件所在的目录路径
const dir = path.dirname(filePath);

// 递归创建目录（如果不存在）
if (!fs.existsSync(dir)) {
  fs.mkdirSync(dir, { recursive: true });
}

// 写入文件
fs.writeFileSync(filePath, '这是文件的内容', 'utf8');

console.log('文件写入成功');

cypress 数据库插件

Dennis Zhang — Wed, 11 Sep 2024 15:01:58 +0000

1、MySQL

npm install mysql2

配置 cypress.config.js

const mysql = require('mysql2/promise');

module.exports = (on, config) => {
  on('task', {
    async queryDatabase(query) {
      const connection = await mysql.createConnection({
        host: process.env.DB_HOST || 'localhost',
        user: process.env.DB_USER || 'root',
        password: process.env.DB_PASSWORD || 'password',
        database: process.env.DB_NAME || 'your_database',
      });

      const [results] = await connection.execute(query);
      return results;
    },
  });
};

it('should query the database', () => {
  cy.task('queryDatabase', 'SELECT * FROM users').then((results) => {
    expect(results).to.have.length.greaterThan(0);
  });
});

2、PostgreSQL

npm install pg

配置 cypress.config.js

const { Client } = require('pg');

module.exports = (on, config) => {
  on('task', {
    async queryPostgres(query) {
      const client = new Client({
        host: process.env.PG_HOST || 'localhost',
        user: process.env.PG_USER || 'postgres',
        password: process.env.PG_PASSWORD || 'password',
        database: process.env.PG_DATABASE || 'your_database',
      });

      await client.connect();
      const res = await client.query(query);
      await client.end();
      return res.rows;
    },
  });
};

it('should query the Postgres database', () => {
// task 参数来源于task注册的函数名
  cy.task('queryPostgres', 'SELECT * FROM users').then((results) => {
    expect(results).to.have.length.greaterThan(0);
  });
});

db2

npm install ibm_db

配置文件

const { defineConfig } = require("cypress");
const ibmdb = require("ibm_db");

module.exports = defineConfig({
  e2e: {
    setupNodeEvents(on, config) {
      // implement node event listeners here
      on("task", {
        queryDb2(query) {
          const connStr =
            "DATABASE=<your_db>;HOSTNAME=<your_host>;UID=<your_user>;PWD=<your_password>;PORT=<your_port>;PROTOCOL=TCPIP";

          return new Promise((resolve, reject) => {
            ibmdb.open(connStr, (err, conn) => {
              if (err) {
                reject(err);
                return;
              }

              conn.query(query, (err, data) => {
                if (err) {
                  reject(err);
                } else {
                  resolve(data);
                }
                conn.close();
              });
            });
          });
        }
      });
    }
  }
});

cypress 自定义命令获取文本

Dennis Zhang — Mon, 09 Sep 2024 03:20:21 +0000

Cypress.Commands.add("getMyNumber", () => {
  let myNumber;
  // eq 从0开始，获取第二个，within 在card元素里查找
  cy.get(".card", { timeout: 3000 })
    .eq(1)
    .should("be.visible")
    .within(() => {
      cy.get("h2")
        .invoke("text")
        .then((text) => {
          // 获取文本
          myNumber = text;
          //   cy.log(text);  // 输出到 Cypress 的日志中
        });
    })
    .then(() => {
      // 上一步完成之后，返回给命令调用 传递值
      return myNumber;
    });
});

cypress查找元素

Dennis Zhang — Fri, 06 Sep 2024 03:07:07 +0000

cy.get('.item') // 这会返回所有 class 为 'item' 的元素
cy.get('.item').eq(1) // 获取第二个 'item' 元素
cy.get('.item').eq(1).should('contain', 'Item 2') // 检查第二个 .item 元素是否包含文本 "Item 2"。

cy.get('.xxx').then($btn => {  
// 判断按钮是否被禁用  
      if ($btn.prop('disabled')) { 
}
})
// .invoke('text') 方法来获取元素内的文本
cy.get('.item').eq(1).invoke('text').then((text) => {
  // 此时 text 包含了第二个 .item 元素的文本，即 'Item 2' 
  cy.log(text); // 在 Cypress 的日志中显示获取的文本
});


cy.get('.item').eq(1).invoke('text').should('eq', 'Item 2');
// 这会检查第二个 item 元素的文本是否正好等于 "Item 2"。

// 链式调用，确保后续的操作依赖于 then() 回调的结果，应该继续在 then() 内部链式操作。这样可以确保代码按预期顺序执行。


cy.get('selector').then(($el) => {
  const text = $el.text(); // 获取文本
  cy.log(text);            // 打印文本
  return text;             // 返回文本以继续链式调用
}).then((text) => {
  // 你可以在这里使用 text 进行操作
  cy.get('xxx').should('be.visible');  // 获取另一个元素并验证可见性
});


Cypress.Commands.add('getIframe', (iframeSelector) => {
  return cy.get(iframeSelector)
    .its('0.contentDocument.body')  // 进入 iframe 的 body
    .should('not.be.empty')         // 确保 iframe 内部不为空
    .then(cy.wrap);                 // 将其包装为 Cypress 命令链的一部分，之后调用才能使用then方法获取
});

// 使用自定义命令获取 iframe 内的元素
cy.getIframe('iframe#myIframe')      // 获取 iframe
  .find('button#myButton')           // 查找 iframe 内的元素
  .click();                          // 对找到的元素进行操作
// 获取父元素
cy.get('your-child-selector').parent()
cy.get('your-child-selector').parents('specific-parent-selector')

iframe操作别名

cy.get('iframe').iframe().as('myIframe'); // 选择 iframe 并赋予别名

cy.get('@myIframe') // 使用别名访问 iframe
  .find('selector-in-iframe') // 在 iframe 内查找元素
  .click(); // 执行操作

cucumber-html-reporter 要求的JSON格式

Dennis Zhang — Mon, 02 Sep 2024 12:28:11 +0000

[
  {
    "uri": "path/to/feature/file.feature",
    "id": "some-id",
    "name": "Feature Name",
    "keyword": "Feature",
    "elements": [
      {
        "id": "scenario-id",
        "keyword": "Scenario",
        "name": "Scenario Name",
        "description": "Scenario description",
        "steps": [
          {
            "keyword": "Given",
            "name": "Step name",
            "result": {
              "status": "passed",
              "duration": 123456789
            }
          },
          {
            "keyword": "When",
            "name": "Another step name",
            "result": {
              "status": "failed",
              "error_message": "Error message",
              "duration": 123456789
             },
             "embeddings":[
                {
                  "mime_type":"image/png",
                  "data":"<base64-encoded-scrennshot>"
                }
             ]
          }
        ]
      }
    ]
  }
]

字段解释

uri: 特性文件的路径。
id: 唯一标识符，通常是自动生成的。
feature: 包含有关特性的详细信息。
name: 特性的名称。
description: 特性的描述。
id: 唯一标识符，通常是自动生成的。
keyword: 关键字，例如 Feature。
elements: 包含场景或背景的数组。
id: 场景或背景的唯一标识符。
keyword: 关键字，例如 Scenario 或 Background。
name: 场景或背景的名称。
description: 场景或背景的描述。
steps: 包含步骤的数组。
keyword: 步骤的关键字，例如 Given, When, Then。
name: 步骤的名称。
result: 步骤的结果。
status: 步骤的状态，例如 passed, failed, skipped。
error_message: 失败时的错误消息。
duration: 步骤的执行时间（以毫秒为单位）。
embeddings: 图片信息

moment的使用

Dennis Zhang — Mon, 02 Sep 2024 02:31:24 +0000

const moment = require('moment'); // 如果你使用的是 Node.js，需要引入 moment

// startOf('day'): 将时间设置为当天的开始，即当天的零点时间。
const startOfToday = moment().startOf('day');  

console.log(startOfToday.format()); // 输出类似于 "2024-08-31T00:00:00+08:00" 的时间格式

//startOf('month'): 将时间设置为当前月份的第一天零点（午夜）时间。
const startOfMonth = moment().startOf('month');

// 晚于今天，第二个参数 'year', 'month', 'day'
someDate.isAfter(today, 'day')
date2.isAfter(date1, 'month') 只会比较年份和月份部分

if (someDate.isSameOrAfter(today)) {
  console.log('这个日期在今天之后或等于今天。');
}

// 格式化
const dateStr = '2024-08-31 14:30:00'; // 日期字符串
const format = 'YYYY-MM-DD HH:mm:ss'; // 日期格式

const dateObj = moment(dateStr, format); // 解析日期字符串为 Moment 对象
console.log(dateObj.format()); // 输出类似于 "2024-08-31T14:30:00+08:00" 的时间格式


console.log(now.format('YYYY-MM-DD'));        // 输出: 2024-08-31 (年-月-日)
console.log(now.format('YYYY-MM-DD HH:mm:ss')); // 输出: 2024-08-31 15:45:30 (年-月-日 时:分:秒)
console.log(now.format('MMMM Do YYYY, h:mm:ss a')); // 输出: August 31st 2024, 3:45:30 pm
console.log(now.format('ddd, hA'));          // 输出: Sat, 3PM (星期缩写, 12小时制时间)

自定义格式化

_你可以根据需要自定义格式，使用不同的格式化标记来表示不同的时间部分：
_
YYYY: 四位数年份（例如，2024）
YY: 两位数年份（例如，24）
MMMM: 完整月份名称（例如，August）
MMM: 月份的缩写（例如，Aug）
MM: 两位数的月份（例如，08）
M: 月份，去掉前导零（例如，8）
DD: 两位数的日期（例如，09）
D: 日期，去掉前导零（例如，9）
dddd: 星期的全称（例如，Saturday）
ddd: 星期的缩写（例如，Sat）
HH: 24小时制的小时（例如，15）
hh: 12小时制的小时（例如，03）
mm: 分钟，两位数（例如，09）
ss: 秒，两位数（例如，05）
a: 小写的上午/下午（例如，am 或 pm）
A: 大写的上午/下午（例如，AM 或 PM）

cucumber-html-reporter生成测试报告表格

Dennis Zhang — Fri, 23 Aug 2024 10:22:38 +0000

npm install cypress cypress-cucumber-preprocessor cucumber-html-reporter --save-dev

cypress.config.js配置

const { defineConfig } = require('cypress')
const createBundler = require('@bahmutov/cypress-esbuild-preprocessor')
const addCucumberPreprocessorPlugin = require('@badeball/cypress-cucumber-preprocessor').addCucumberPreprocessorPlugin
const createEsbuildPlugin = require('@badeball/cypress-cucumber-preprocessor/esbuild').createEsbuildPlugin
const fs = require('fs');
const path = require('path');


module.exports = defineConfig({
  e2e: {
    async setupNodeEvents(on, config) {
      const bundler = createBundler({
        plugins: [createEsbuildPlugin(config)],
      })
      on('file:preprocessor', bundler)
      await addCucumberPreprocessorPlugin(on, config)

   // 自定义报告输出路径（例如，JSON 格式）
      on('after:run', (results) => {
        try {
          const jsonReportPath = path.join(config.projectRoot, 'report', 'cucumber_report.json');

          // 确保报告目录report存在
          const reportDir = path.dirname(jsonReportPath);
          if (!fs.existsSync(reportDir)) {
            fs.mkdirSync(reportDir, { recursive: true });
          }

          // 将测试结果写入 JSON 文件
          fs.writeFileSync(jsonReportPath, JSON.stringify(results, null, 2));
        } catch (err) {
          console.error('Failed to write the report file:', err);
        }
      });

      return config
    },
    specPattern: 'cypress/e2e/**/*.feature', // 设置 .feature 文件的路径
  },
})

在 package.json 的 scripts 部分

"scripts": {
  "test": "cypress run",
  "posttest": "node generate-html-report.js",
  "report":"npm run test && node convert-report.js && node generate-html-report.js "
}

convert-report.js 脚本转换json

const fs = require('fs');

const inputFilePath = 'report/cucumber_report.json'; // Cypress 生成的 JSON 报告
const outputFilePath = 'report/converted_report.json'; // 转换后的 JSON 文件

fs.readFile(inputFilePath, 'utf8', (err, data) => {
  if (err) {
    console.error('Error reading the input file:', err);
    return;
  }

  let results;
  try {
    results = JSON.parse(data);
  } catch (err) {
    console.error('Error parsing JSON:', err);
    return;
  }

  const converted = {
    features: results.runs.map(run => ({
      keyword: "Feature",
      name: run.spec.name,
      uri: run.spec.relative,
      elements: run.tests.map(test => ({
        keyword: "Scenario",
        name: test.title.join(' '),
        steps: test.steps.map(step => ({
          keyword: "Step",
          name: step.name,
          result: {
            status: step.state,
            duration: step.duration
          }
        }))
      }))
    }))
  };

  fs.writeFile(outputFilePath, JSON.stringify(converted, null, 2), err => {
    if (err) {
      console.error('Error writing the output file:', err);
    } else {
      console.log('Report converted successfully!');
    }
  });
});

cucumber-html-reporter 生成 HTML 报告

创建一个名为 generate-html-report.js 的文件

const reporter = require('cucumber-html-reporter');

const options = {
  theme: 'bootstrap',
  jsonFile: 'report/converted_report.json', // 你的 JSON 报告的路径
  output: 'report/cucumber_report.html',   // 生成的 HTML 报告的路径
  reportSuiteAsScenarios: true,
  launchReport: true,
  metadata: {
    "App Version": "0.1.0",
    "Test Environment": "STAGING",
    "Browser": "Chrome  91.0.4472.124",
    "Platform": "Windows 10",
    "Parallel": "Scenarios",
    "Executed": "Remote"
  }
};

reporter.generate(options);

jest.mock()模拟某个模块

Dennis Zhang — Mon, 19 Aug 2024 09:31:22 +0000

假设 example.js 现在包含多个导出：

// example.js
export default function fetchData() {
  return 'real data';
}

export function otherFunction() {
  return 'something else';
}

export function otherFunc() {
  return 'something else';
}

模拟默认导出的 fetchData 函数，同时保留 otherFunction：

import fetchData, { otherFunction } from './example';

jest.setTimeout(30000) // 设置整体测试超时时间
jest.resetModules();  // 重置模块缓存

jest.mock('./example', () => {
  const actualModule = jest.requireActual('./example');
  return {
    __esModule: true,// 表明这是一个 ES 模块
    ...actualModule, // 保留其他导出
    otherFunction:jest.fn().mockImplementtation(()=>{
      return {  
        ss:xxx
       }
   })
    default: jest.fn(() => 'mocked data'), // 模拟默认导出
  };
});

test('should return mocked data', () => {
  expect(fetchData()).toBe('mocked data');
});

test('otherFunction should return real data', () => {
  expect(otherFunction()).toBe('something else');
});

cypress-cucumber-preprocessor查找步骤文件的规则

Dennis Zhang — Tue, 13 Aug 2024 08:05:57 +0000

如果在support下创建了step_definitions文件夹，步骤文件就只会在这个文件夹下查找，并且是全部文件，可以有公共步骤文件；
如果没有step_definitions文件夹，就会在feature同目录查找相同文件名的步骤文件