atom/packages/git-diff/spec/git-diff-spec.js

const path = require('path');
const fs = require('fs-plus');
const temp = require('temp');

describe('GitDiff package', () => {
  let editor, editorElement, projectPath;

  beforeEach(() => {
    spyOn(window, 'setImmediate').andCallFake(fn => fn());

    projectPath = temp.mkdirSync('git-diff-spec-');
    const otherPath = temp.mkdirSync('some-other-path-');

    fs.copySync(path.join(__dirname, 'fixtures', 'working-dir'), projectPath);
    fs.moveSync(
      path.join(projectPath, 'git.git'),
      path.join(projectPath, '.git')
    );
    atom.project.setPaths([otherPath, projectPath]);

    jasmine.attachToDOM(atom.workspace.getElement());

    waitsForPromise(() =>
      atom.workspace.open(path.join(projectPath, 'sample.js'))
    );

    runs(() => {
      editor = atom.workspace.getActiveTextEditor();
      editorElement = editor.getElement();
    });

    waitsForPromise(() => atom.packages.activatePackage('git-diff'));
  });

  describe('when the editor has modified lines', () => {
    it('highlights the modified lines', () => {
      expect(editorElement.querySelectorAll('.git-line-modified').length).toBe(
        0
      );
      editor.insertText('a');
      advanceClock(editor.getBuffer().stoppedChangingDelay);
      expect(editorElement.querySelectorAll('.git-line-modified').length).toBe(
        1
      );
      expect(editorElement.querySelector('.git-line-modified')).toHaveData(
        'buffer-row',
        0
      );
    });
  });

  describe('when the editor has added lines', () => {
    it('highlights the added lines', () => {
      expect(editorElement.querySelectorAll('.git-line-added').length).toBe(0);
      editor.moveToEndOfLine();
      editor.insertNewline();
      editor.insertText('a');
      advanceClock(editor.getBuffer().stoppedChangingDelay);
      expect(editorElement.querySelectorAll('.git-line-added').length).toBe(1);
      expect(editorElement.querySelector('.git-line-added')).toHaveData(
        'buffer-row',
        1
      );
    });
  });

  describe('when the editor has removed lines', () => {
    it('highlights the line preceeding the deleted lines', () => {
      expect(editorElement.querySelectorAll('.git-line-added').length).toBe(0);
      editor.setCursorBufferPosition([5]);
      editor.deleteLine();
      advanceClock(editor.getBuffer().stoppedChangingDelay);
      expect(editorElement.querySelectorAll('.git-line-removed').length).toBe(
        1
      );
      expect(editorElement.querySelector('.git-line-removed')).toHaveData(
        'buffer-row',
        4
      );
    });
  });

  describe('when the editor has removed the first line', () => {
    it('highlights the line preceeding the deleted lines', () => {
      expect(editorElement.querySelectorAll('.git-line-added').length).toBe(0);
      editor.setCursorBufferPosition([0, 0]);
      editor.deleteLine();
      advanceClock(editor.getBuffer().stoppedChangingDelay);
      expect(
        editorElement.querySelectorAll('.git-previous-line-removed').length
      ).toBe(1);
      expect(
        editorElement.querySelector('.git-previous-line-removed')
      ).toHaveData('buffer-row', 0);
    });
  });

  describe('when a modified line is restored to the HEAD version contents', () => {
    it('removes the diff highlight', () => {
      expect(editorElement.querySelectorAll('.git-line-modified').length).toBe(
        0
      );
      editor.insertText('a');
      advanceClock(editor.getBuffer().stoppedChangingDelay);
      expect(editorElement.querySelectorAll('.git-line-modified').length).toBe(
        1
      );
      editor.backspace();
      advanceClock(editor.getBuffer().stoppedChangingDelay);
      expect(editorElement.querySelectorAll('.git-line-modified').length).toBe(
        0
      );
    });
  });

  describe('when a modified file is opened', () => {
    it('highlights the changed lines', () => {
      fs.writeFileSync(
        path.join(projectPath, 'sample.txt'),
        'Some different text.'
      );
      let nextTick = false;

      waitsForPromise(() =>
        atom.workspace.open(path.join(projectPath, 'sample.txt'))
      );

      runs(() => {
        editorElement = atom.workspace.getActiveTextEditor().getElement();
      });

      setImmediate(() => {
        nextTick = true;
      });

      waitsFor(() => nextTick);

      runs(() => {
        expect(
          editorElement.querySelectorAll('.git-line-modified').length
        ).toBe(1);
        expect(editorElement.querySelector('.git-line-modified')).toHaveData(
          'buffer-row',
          0
        );
      });
    });
  });

  describe('when the project paths change', () => {
    it("doesn't try to use the destroyed git repository", () => {
      editor.deleteLine();
      atom.project.setPaths([temp.mkdirSync('no-repository')]);
      advanceClock(editor.getBuffer().stoppedChangingDelay);
    });
  });

  describe('move-to-next-diff/move-to-previous-diff events', () => {
    it('moves the cursor to first character of the next/previous diff line', () => {
      editor.insertText('a');
      editor.setCursorBufferPosition([5]);
      editor.deleteLine();
      advanceClock(editor.getBuffer().stoppedChangingDelay);

      editor.setCursorBufferPosition([0]);
      atom.commands.dispatch(editorElement, 'git-diff:move-to-next-diff');
      expect(editor.getCursorBufferPosition()).toEqual([4, 4]);

      atom.commands.dispatch(editorElement, 'git-diff:move-to-previous-diff');
      expect(editor.getCursorBufferPosition()).toEqual([0, 0]);
    });

    it('wraps around to the first/last diff in the file', () => {
      editor.insertText('a');
      editor.setCursorBufferPosition([5]);
      editor.deleteLine();
      advanceClock(editor.getBuffer().stoppedChangingDelay);

      editor.setCursorBufferPosition([0]);
      atom.commands.dispatch(editorElement, 'git-diff:move-to-next-diff');
      expect(editor.getCursorBufferPosition()).toEqual([4, 4]);

      atom.commands.dispatch(editorElement, 'git-diff:move-to-next-diff');
      expect(editor.getCursorBufferPosition()).toEqual([0, 0]);

      atom.commands.dispatch(editorElement, 'git-diff:move-to-previous-diff');
      expect(editor.getCursorBufferPosition()).toEqual([4, 4]);
    });

    describe('when the wrapAroundOnMoveToDiff config option is false', () => {
      beforeEach(() =>
        atom.config.set('git-diff.wrapAroundOnMoveToDiff', false)
      );

      it('does not wraps around to the first/last diff in the file', () => {
        editor.insertText('a');
        editor.setCursorBufferPosition([5]);
        editor.deleteLine();
        advanceClock(editor.getBuffer().stoppedChangingDelay);

        editor.setCursorBufferPosition([0]);
        atom.commands.dispatch(editorElement, 'git-diff:move-to-next-diff');
        expect(editor.getCursorBufferPosition()).toEqual([4, 4]);

        atom.commands.dispatch(editorElement, 'git-diff:move-to-next-diff');
        expect(editor.getCursorBufferPosition()).toEqual([4, 4]);

        atom.commands.dispatch(editorElement, 'git-diff:move-to-previous-diff');
        expect(editor.getCursorBufferPosition()).toEqual([0, 0]);

        atom.commands.dispatch(editorElement, 'git-diff:move-to-previous-diff');
        expect(editor.getCursorBufferPosition()).toEqual([0, 0]);
      });
    });
  });

  describe('when the showIconsInEditorGutter config option is true', () => {
    beforeEach(() => {
      atom.config.set('git-diff.showIconsInEditorGutter', true);
    });

    it('the gutter has a git-diff-icon class', () =>
      expect(editorElement.querySelector('.gutter')).toHaveClass(
        'git-diff-icon'
      ));

    it('keeps the git-diff-icon class when editor.showLineNumbers is toggled', () => {
      atom.config.set('editor.showLineNumbers', false);
      expect(editorElement.querySelector('.gutter')).not.toHaveClass(
        'git-diff-icon'
      );

      atom.config.set('editor.showLineNumbers', true);
      expect(editorElement.querySelector('.gutter')).toHaveClass(
        'git-diff-icon'
      );
    });

    it('removes the git-diff-icon class when the showIconsInEditorGutter config option set to false', () => {
      atom.config.set('git-diff.showIconsInEditorGutter', false);
      expect(editorElement.querySelector('.gutter')).not.toHaveClass(
        'git-diff-icon'
      );
    });
  });
});