protractor_sample1/conf.js

Kenny's sample

const fs = require('fs');
const path = require('path');
const log4js = require('log4js');
const customAppender = require('./customAppender');
// log data arrat
global.logs = [];
global.currentSpec = null;
// config log4js
log4js.configure({
  appenders: { custom: { type: './customAppender' } },
  categories: { default: { appenders: ['custom'], level: 'info' } }
});
const logger = log4js.getLogger();


exports.config = {
  framework: 'jasmine2',
  seleniumAddress: 'http://localhost:4444/wd/hub',
  specs: ['spec.js'],
  capabilities: {
    browserName: 'chrome'
  },
  resultJsonOutputFile: 'report.json',
  onPrepare: function() {
    console.log("debug onPrepare");
    // add self-defined reporter
    jasmine.getEnv().addReporter({
      specStarted: function(result) {
        console.log("debug specStarted");
        global.currentSpec = {
          description: result.description,
          assertions: []
        };
      },
      specDone: function(result) {
        // add current spec log into global
        console.log("debug specDone");

        global.logs = global.logs.concat(global.currentSpec.assertions);
        global.currentSpec = null;
      },
      jasmineDone: function() {
        // get self-defined appender log
        console.log("debug jasmineDone");

        const logEvents = customAppender.logEvents;
        global.logs = global.logs.concat(logEvents);
        //const logFilePath1 = path.join(__dirname, 'report1.json');
        // const logFilePath = path.join(__dirname, 'report.json');
        //fs.writeFileSync(logFilePath1, JSON.stringify(global.logs, null, 2));
        // if(fs.existsSync(logFilePath)) {
        //   const reportLogs = JSON.parse(fs.readFileSync(logFilePath, 'utf-8'));
        //   const combinedLogs = [...global.logs, ...reportLogs]
        //   fs.writeFileSync(logFilePath1, JSON.stringify(combinedLogs, null, 2));
        // }

    }
    });
    // self defined matches
    const addCustomMatchers = function() {
      jasmine.addMatchers({
      toBeBecause: function(value, message) {
        return {
            compare: function(actual, expected, message) {
                var passed = actual == expected;
                var message = message + actual + ". Your expect(toBe): " + expected;
                global.currentSpec.assertions.push({
                  text: `Test ${global.currentSpec.description}`,
                  matcher: 'toBeBecause',
                  actual: actual,
                  expected: expected,
                  passed: passed,
                  result: passed ? 'PASS' : 'FAIL',
                  message: message,
                  time: new Date().toISOString(),
                  time_milliseconds: new Date().getMilliseconds()
                });
                return {
                    pass: passed,
                    message: message
                };
            }
        };
    },
    toContainBecause: function(string, message) {
        return {
            compare: function(actual, expected, message) {
                var passed = actual.indexOf(expected) > -1;
                var message = message + actual + ". Your expect(contain): " + expected;
                global.currentSpec.assertions.push({
                  text: `Test ${global.currentSpec.description}`,
                  matcher: 'toContainBecause',
                  actual: actual,
                  expected: expected,
                  passed: passed,
                  result: passed ? 'PASS' : 'FAIL',
                  message: message,
                  time: new Date().toISOString(),
                  time_milliseconds: new Date().getMilliseconds()
                });
                return {
                    pass: passed,
                    message: message
                };
            }
        };
    },
    toNotContainBecause: function(string, message) {
        return {
            compare: function(actual, expected, message) {
                var passed = actual.indexOf(expected) < 0;
                var message = message + actual + ". Your expect(not contain): " + expected;
                global.currentSpec.assertions.push({
                  text: `Test ${global.currentSpec.description}`,
                  matcher: 'toNotContainBecause',
                  actual: actual,
                  expected: expected,
                  passed: passed,
                  result: passed ? 'PASS' : 'FAIL',
                  message: message,
                  time: new Date().toISOString(),
                  time_milliseconds: new Date().getMilliseconds()
                });
                return {
                    pass: passed,
                    message: message
                };
            }
        };
    },
    toMatchScreen: function() {
        return {
            compare: function(actual, expected) {
                var percent = +((actual.differences / actual.dimension) * 100).toFixed(2);
                var passed = ((actual.code === BlinkDiff.RESULT_IDENTICAL) || (actual.code === BlinkDiff.RESULT_SIMILAR));
                var message = util.format("Image is visibly different by %s pixels, %s %", actual.differences, percent)
                global.currentSpec.assertions.push({
                  text: `Test ${global.currentSpec.description}`,
                  matcher: 'toMatchScreen',
                  actual: actual,
                  expected: expected,
                  passed: passed,
                  result: passed ? 'PASS' : 'FAIL',
                  message: message,
                  time: new Date().toISOString(),
                  time_milliseconds: new Date().getMilliseconds()
                });
                return {
                    pass: passed,
                    message: message
                };
            }
        };
    },
    toBe: function() {
      return {
        compare: function(actual, expected) {
          const result = actual === expected;
          const message = result ? 'Passed' : `Expected ${actual} to be ${expected}`;
          global.currentSpec.assertions.push({
            text: `Test ${global.currentSpec.description}`,
            matcher: 'toBe',
            actual: actual,
            expected: expected,
            passed: result,
            result: result ? 'PASS' : 'FAIL',
            message: message,
            time: new Date().toISOString(),
            time_milliseconds: new Date().getMilliseconds()
          });
          return {
            pass: result,
            message: message
          };
        }
      };
    },
    toEqual: function() {
      return {
        compare: function(actual, expected) {
          const result = jasmine.matchersUtil.equals(actual, expected);
          const message = result ? 'Passed' : `Expected ${actual} to equal ${expected}`;
          global.currentSpec.assertions.push({
            text: `Test ${global.currentSpec.description}`,
            matcher: 'toEqual',
            actual: actual,
            expected: expected,
            passed: result,
            result: result ? 'PASS' : 'FAIL',
            message: message,
            time: new Date().toISOString(),
            time_milliseconds: new Date().getMilliseconds()
          });
          return {
            pass: result,
            message: message
          };
        }
      };
    }
    });
    };
    // 在每个测试开始之前添加自定义匹配器
    beforeEach(addCustomMatchers);
  },

  afterLaunch: function() {
    console.log("debug afterLaunch");
    const logFilePath = path.join(__dirname, 'report.json');
    const logFilePath1 = path.join(__dirname, 'report1.json');
    if(fs.existsSync(logFilePath)) {
      console.log("report.json exists in afterLaunch");
      const reportLogs = JSON.parse(fs.readFileSync(logFilePath, 'utf-8'));
      console.log(JSON.stringify(reportLogs, null, 2));
      const combinedLogs = [...global.logs, ...reportLogs];
      console.log(JSON.stringify(combinedLogs, null, 2));
      fs.writeFileSync(logFilePath1, JSON.stringify(combinedLogs, null, 2));
    }
    else {
      console.log("report.json not exists in afterLaunch");
      fs.writeFileSync(logFilePath1, JSON.stringify(global.logs, null, 2));
    }
  }
};