git-commit-guide/engine.test.js

Commitizen adapter following the conventional-changelog format and also asking for JIRA issue with Smart Commits.

let chai = require('chai');
let chalk = require('chalk');
let mock = require('mock-require');
let semver = require('semver');

let engine = require('./engine');
let types = require('./types');
let defaults = require('./defaults');

let expect = chai.expect;
chai.should();

let defaultOptions = defaults;

let type = 'func';
let scope = 'everything';
let jira = 'JNR-123';
let subject = 'testing123';

let body = 'A quick brown fox jumps over the dog';
let shortBody = 'a';
let longBody =
  'a a aa a aa a aa a aa a aa a aa a aa a aa a aa a aa a aa a aa a aa a aa\n' +
  'aa a aa a aa a aa a aa a aa a aa a aa a aa a aa a aa a aa a aa a aa a aa\n' +
  'a aa a aa a aa a aa aa a aa a aa a aa a aa a aa a aa a aa a aa a aa a aa\n' +
  'a aa a aa a aa a aa a aa a aa a aa a aa a';
let longBodySplit =
  longBody.slice(0, defaultOptions.maxLineWidth).trim() +
  '\n' +
  longBody.slice(defaultOptions.maxLineWidth, 2 * defaultOptions.maxLineWidth).trim() +
  '\n' +
  longBody.slice(defaultOptions.maxLineWidth * 2, longBody.length).trim();

let breakingChange = 'BREAKING CHANGE: ';
let breaking = 'asdhdfkjhbakjdhjkashd adhfajkhs asdhkjdsh ahshd';

describe('commit message', function() {
  it('only header w/ out scope', function() {
    expect(
      commitMessage({
        type,
        subject
      })
    ).to.equal(`${type}: ${subject}`);
  });
  it('only header w/ scope', function() {
    expect(
      commitMessage({
        type,
        scope,
        subject
      })
    ).to.equal(`${type}(${scope}): ${subject}`);
  });
  it('header and body w/ out scope', function() {
    expect(
      commitMessage({
        type,
        subject,
        body
      })
    ).to.equal(`${type}: ${subject}\n\n${body}`);
  });
  it('header and body w/ scope', function() {
    expect(
      commitMessage({
        type,
        scope,
        subject,
        body
      })
    ).to.equal(`${type}(${scope}): ${subject}\n\n${body}`);
  });
  it('header, body and issues w/ out scope', function() {
    expect(
      commitMessage({
        type,
        subject,
        body,
        jira
      })
    ).to.equal(`${type}: ${subject}\n\n${body}\n\n${jira}`);
  });
  it('header, body and issues w/ scope', function() {
    expect(
      commitMessage({
        type,
        scope,
        subject,
        body,
        jira
      })
    ).to.equal(`${type}(${scope}): ${subject}\n\n${body}\n\n${jira}`);
  });
  it('header and long body w/ out scope', function() {
    expect(
      commitMessage({
        type,
        subject,
        body: longBody,
        jira
      })
    ).to.equal(`${type}: ${subject}\n\n${longBodySplit}\n\n${jira}`);
  });
  it('header and long body w/ scope', function() {
    expect(
      commitMessage({
        type,
        scope,
        subject,
        body: longBody,
        jira
      })
    ).to.equal(`${type}(${scope}): ${subject}\n\n${longBodySplit}\n\n${jira}`);
  });
  it('header, long body, breaking change, and long issues w/ scope', function() {
    expect(
      commitMessage({
        type,
        scope,
        subject,
        body: longBody,
        jira,
        breaking
      })
    ).to.equal(`${type}(${scope}): ${subject}\n\n${longBodySplit}\n\n${breakingChange}${breaking}\n\n${jira}`);
  });
  it('header, long body, breaking change (with prefix entered), and long issues w/ scope', function() {
    expect(
      commitMessage({
        type,
        scope,
        subject,
        body: longBody,
        jira,
        breaking: `${breakingChange}${breaking}`
      })
    ).to.equal(`${type}(${scope}): ${subject}\n\n${longBodySplit}\n\n${breakingChange}${breaking}\n\n${jira}`);
  });
});

describe('validation', function() {
  it('subject exceeds max length', function() {
    expect(() =>
      commitMessage({
        type,
        scope,
        jira,
        subject: shortBody
      })
    ).to.throw(`A descrição deve conter ao menos 2 caracteres`);
  });
  it('empty subject', function() {
    expect(() =>
      commitMessage({
        type,
        scope,
        subject: ''
      })
    ).to.throw(`A descrição deve conter ao menos 2 caracteres`);
  });
  it('empty jira if not optional', function() {
    expect(() =>
      commitMessage(
        {
          type,
          scope,
          jira: '',
          subject
        },
        { jiraOptional: false }
      )
    ).to.throw(
      `Deve-se especificar código da tarefa, caso contrário, especifique que não afetará tarefas no Jira (Ctrl+C para cancelar)`
    );
  });
});

describe('defaults', function() {
  it('defaultType default', function() {
    expect(questionDefault('type')).to.be.undefined;
  });
  it('defaultType options', function() {
    expect(questionDefault('type', customOptions({ defaultType: type }))).to.equal(type);
  });
  it('defaultScope default', function() {
    expect(questionDefault('scope')).to.be.undefined;
  });
  it('defaultScope options', () =>
    expect(questionDefault('scope', customOptions({ defaultScope: scope }))).to.equal(scope));

  it('defaultSubject default', () => expect(questionDefault('subject')).to.be.undefined);
  it('defaultSubject options', function() {
    expect(
      questionDefault(
        'subject',
        customOptions({
          defaultSubject: subject
        })
      )
    ).to.equal(subject);
  });
  it('defaultBody default', function() {
    expect(questionDefault('body')).to.be.undefined;
  });
  it('defaultBody options', function() {
    expect(questionDefault('body', customOptions({ defaultBody: body }))).to.equal(body);
  });
  it('defaultIssues default', function() {
    expect(questionDefault('issues')).to.be.undefined;
  });
});

describe('filter', function() {
  it('lowercase scope', () => expect(questionFilter('scope', 'HelloMatt')).to.equal('hellomatt'));
});

describe('when', function() {
  it('breaking by default', () => expect(questionWhen('breaking', {})).to.be.undefined);
  it('breaking when isBreaking', () =>
    expect(
      questionWhen('breaking', {
        isBreaking: true
      })
    ).to.be.true);
});

describe('commitlint config header-max-length', function() {
  //commitlint config parser only supports Node 6.0.0 and higher
  if (semver.gte(process.version, '6.0.0')) {
    function mockOptions(headerMaxLength) {
      var options = undefined;
      mock('./engine', function(opts) {
        options = opts;
      });
      if (headerMaxLength) {
        mock('cosmiconfig', function() {
          return {
            load: function(cwd) {
              return {
                filepath: cwd + '/.commitlintrc.js',
                config: {
                  rules: {
                    'header-max-length': [2, 'always', headerMaxLength]
                  }
                }
              };
            }
          };
        });
      }

      mock.reRequire('./index');
      try {
        return mock
          .reRequire('@commitlint/load')()
          .then(function() {
            return options;
          });
      } catch (err) {
        return Promise.resolve(options);
      }
    }

    afterEach(function() {
      delete require.cache[require.resolve('./index')];
      delete require.cache[require.resolve('@commitlint/load')];
      delete process.env.CZ_MAX_HEADER_WIDTH;
      mock.stopAll();
    });

    it('with no environment or commitizen config override', function() {
      return mockOptions(72).then(function(options) {
        expect(options).to.have.property('maxHeaderWidth', 72);
      });
    });

    it('with environment variable override', function() {
      process.env.CZ_MAX_HEADER_WIDTH = '105';
      return mockOptions(72).then(function(options) {
        expect(options).to.have.property('maxHeaderWidth', 105);
      });
    });

    it('with commitizen config override', function() {
      mock('commitizen', {
        configLoader: {
          load: function() {
            return {
              maxHeaderWidth: 103
            };
          }
        }
      });
      return mockOptions(72).then(function(options) {
        expect(options).to.have.property('maxHeaderWidth', 103);
      });
    });
  } else {
    //Node 4 doesn't support commitlint so the config value should remain the same
    it('default value for Node 4', function() {
      return mockOptions(72).then(function(options) {
        expect(options).to.have.property('maxHeaderWidth', 100);
      });
    });
  }
});

describe('questions', function() {
  it('default jira question', function() {
    expect(questionPrompt('jira')).to.be.eq('Digite o código da tarefa do JIRA (JNR-12345):');
  });
  it('optional jira question', function() {
    expect(questionPrompt('jira', [], { jiraOptional: true })).to.be.eq(
      'Digite o código da tarefa do JIRA (JNR-12345):'
    );
  });
  it('scope with list', function() {
    expect(questionPrompt('scope', [], { scopes: ['scope1', 'scope2'] })).to.be.eq(
      'Qual é o escopo da mudança (ex.: componente ou nome do arquivo): (selecione na lista)'
    );
  });
  it('scope without list', function() {
    expect(questionPrompt('scope')).to.be.eq(
      'Qual é o escopo da mudança (ex.: componente ou nome do arquivo): (pressione enter para ignorar)'
    );
  });
});

function commitMessage(answers, options) {
  options = options || defaultOptions;
  let result = null;
  engine(options).prompter(
    {
      prompt: function(questions) {
        return {
          then: function(finalizer) {
            processQuestions(questions, answers, options);
            finalizer(answers);
          }
        };
      },
      registerPrompt: () => {}
    },
    function(message) {
      result = message;
    },
    true
  );
  return result;
}

function processQuestions(questions, answers, options) {
  for (let i in questions) {
    let question = questions[i];

    let answer = answers[question.name];
    let validation = answer === undefined || !question.validate ? true : question.validate(answer, answers);
    if (validation !== true) {
      throw new Error(validation || `Answer '${answer}' to question '${question.name}' was invalid`);
    }
    if (question.filter && answer) {
      answers[question.name] = question.filter(answer);
    }
  }
}

function getQuestions(options) {
  options = options || defaultOptions;
  let result = null;
  engine(options).prompter({
    prompt: function(questions) {
      result = questions;
      return {
        then: function() {}
      };
    },
    registerPrompt: () => {}
  });
  return result;
}

function getQuestion(name, options) {
  options = options || defaultOptions;
  let questions = getQuestions(options);
  for (let i in questions) {
    if (questions[i].name === name) {
      return questions[i];
    }
  }
  return false;
}

function questionPrompt(name, answers, options) {
  options = options || defaultOptions;
  let question = getQuestion(name, options);
  return question.message && typeof question.message === 'string' ? question.message : question.message(answers);
}

function questionTransformation(name, answers, options) {
  options = options || defaultOptions;
  let question = getQuestion(name, options);
  return question.transformer && question.transformer(answers[name], answers, options);
}

function questionFilter(name, answer, options) {
  options = options || defaultOptions;
  let question = getQuestion(name, options);
  return question.filter && question.filter(typeof answer === 'string' ? answer : answer[name]);
}

function questionDefault(name, options) {
  options = options || defaultOptions;
  let question = getQuestion(name, options);
  return question.default;
}

function questionWhen(name, answers, options) {
  options = options || defaultOptions;
  let question = getQuestion(name, options);
  return question.when(answers);
}

function customOptions(options) {
  Object.keys(defaultOptions).forEach(key => {
    if (options[key] === undefined) {
      options[key] = defaultOptions[key];
    }
  });
  return options;
}