import path from 'path';

import fs from 'fs';

import React from 'react';

import {shallow, mount} from 'enzyme';

import dedent from 'dedent-js';

import {cloneRepository, buildRepository} from '../helpers';

import {GitError} from '../../lib/git-shell-out-strategy';

import Repository from '../../lib/models/repository';

import ResolutionProgress from '../../lib/models/conflicts/resolution-progress';

import RootController from '../../lib/controllers/root-controller';

describe('RootController', function() {

let atomEnv, app;

let workspace, commandRegistry, notificationManager, tooltips, config, confirm, deserializers, grammars, project;

let getRepositoryForWorkdir, destroyGitTabItem, destroyGithubTabItem, removeFilePatchItem;

beforeEach(function() {

atomEnv = global.buildAtomEnvironment();

workspace = atomEnv.workspace;

commandRegistry = atomEnv.commands;

deserializers = atomEnv.deserializers;

grammars = atomEnv.grammars;

notificationManager = atomEnv.notifications;

tooltips = atomEnv.tooltips;

config = atomEnv.config;

project = atomEnv.project;

getRepositoryForWorkdir = sinon.stub();

destroyGitTabItem = sinon.spy();

destroyGithubTabItem = sinon.spy();

removeFilePatchItem = sinon.spy();

const absentRepository = Repository.absent();

const emptyResolutionProgress = new ResolutionProgress();

confirm = sinon.stub(atomEnv, 'confirm');

app = (

<RootController

workspace={workspace}

commandRegistry={commandRegistry}

deserializers={deserializers}

grammars={grammars}

notificationManager={notificationManager}

tooltips={tooltips}

config={config}

confirm={confirm}

project={project}

repository={absentRepository}

resolutionProgress={emptyResolutionProgress}

startOpen={false}

filePatchItems={[]}

getRepositoryForWorkdir={getRepositoryForWorkdir}

destroyGitTabItem={destroyGitTabItem}

destroyGithubTabItem={destroyGithubTabItem}

removeFilePatchItem={removeFilePatchItem}

/>

);

});

afterEach(function() {

atomEnv.destroy();

});

describe('initial panel visibility', function() {

let gitTabStubItem, githubTabStubItem;

beforeEach(function() {

const FAKE_PANE_ITEM = Symbol('fake pane item');

gitTabStubItem = {

getDockItem() {

return FAKE_PANE_ITEM;

},

};

githubTabStubItem = {

getDockItem() {

return FAKE_PANE_ITEM;

},

};

});

it('is rendered but not activated when startOpen prop is false', async function() {

const workdirPath = await cloneRepository('multiple-commits');

const repository = await buildRepository(workdirPath);

app = React.cloneElement(app, {repository, gitTabStubItem, githubTabStubItem, startOpen: false});

const wrapper = shallow(app);

const gitDockItem = wrapper.find('DockItem').find({stubItem: gitTabStubItem});

assert.isTrue(gitDockItem.exists());

assert.isFalse(gitDockItem.prop('activate'));

const githubDockItem = wrapper.find('DockItem').find({stubItem: githubTabStubItem});

assert.isTrue(githubDockItem.exists());

assert.isNotTrue(githubDockItem.prop('activate'));

});

it('is initially activated when the startOpen prop is true', async function() {

const workdirPath = await cloneRepository('multiple-commits');

const repository = await buildRepository(workdirPath);

app = React.cloneElement(app, {repository, gitTabStubItem, githubTabStubItem, startOpen: true});

const wrapper = shallow(app);

const gitDockItem = wrapper.find('DockItem').find({stubItem: gitTabStubItem});

assert.isTrue(gitDockItem.exists());

assert.isTrue(gitDockItem.prop('activate'));

const githubDockItem = wrapper.find('DockItem').find({stubItem: githubTabStubItem});

assert.isTrue(githubDockItem.exists());

assert.isNotTrue(githubDockItem.prop('activate'));

});

});

describe('rendering a FilePatch', function() {

it('renders the FilePatchController based on props.filePatchItems', async function() {

const workdirPath = await cloneRepository('three-files');

const repository = await buildRepository(workdirPath);

app = React.cloneElement(app, {repository, filePatchItems: []});

let wrapper = shallow(app);

assert.equal(wrapper.find('FilePatchController').length, 0);

app = React.cloneElement(app, {repository, filePatchItems: [

{key: 1, uri: 'atom-github://file-patch/a.txt?workdir=/foo/bar/baz&stagingStatus=unstaged'},

{key: 2, uri: 'atom-github://file-patch/b.txt?workdir=/foo/bar/baz&stagingStatus=unstaged'},

{key: 3, uri: 'atom-github://file-patch/b.txt?workdir=/foo/bar/baz&stagingStatus=staged'},

{key: 4, uri: 'atom-github://file-patch/c.txt?workdir=/foo/bar/baz&stagingStatus=staged'},

]});

wrapper = shallow(app);

assert.equal(wrapper.find('FilePatchController').length, 4);

assert.isTrue(wrapper.find({filePath: 'a.txt', initialStagingStatus: 'unstaged'}).exists());

assert.isTrue(wrapper.find({filePath: 'b.txt', initialStagingStatus: 'unstaged'}).exists());

assert.isTrue(wrapper.find({filePath: 'b.txt', initialStagingStatus: 'staged'}).exists());

assert.isTrue(wrapper.find({filePath: 'c.txt', initialStagingStatus: 'staged'}).exists());

});

if (path.sep !== '/') {

it('reconstitutes paths from the pane URI with the correct path separator', async function() {

const workdirPath = await cloneRepository('three-files');

const repository = await buildRepository(workdirPath);

app = React.cloneElement(app, {repository, filePatchItems: [

{key: 1, uri: 'atom-github://file-patch/foo/bar/baz/filename.txt?workdir=/foo/bar/baz&stagingStatus=unstaged'},

]});

const wrapper = shallow(app);

assert.equal(wrapper.find('FilePatchController').length, 1);

assert.isTrue(wrapper.find({filePath: path.join('foo', 'bar', 'baz', 'filename.txt')}).exists());

});

}

});

['git', 'github'].forEach(function(tabName) {

describe(`${tabName} tab tracker`, function() {

let wrapper, tabTracker, mockDockItem;

beforeEach(async function() {

const workdirPath = await cloneRepository('multiple-commits');

const repository = await buildRepository(workdirPath);

app = React.cloneElement(app, {repository});

wrapper = shallow(app);

tabTracker = wrapper.instance()[`${tabName}TabTracker`];

sinon.stub(tabTracker, 'focus');

sinon.spy(workspace.getActivePane(), 'activate');

const FAKE_PANE_ITEM = Symbol('fake pane item');

mockDockItem = {

getDockItem() {

return FAKE_PANE_ITEM;

},

};

wrapper.instance()[`${tabName}DockItem`] = mockDockItem;

sinon.stub(workspace.getRightDock(), 'isVisible').returns(true);

sinon.stub(workspace.getRightDock(), 'getPanes').callsFake(() => [{

getActiveItem() { return mockDockItem.active ? FAKE_PANE_ITEM : null; },

}]);

});

describe('reveal', function() {

it('calls workspace.open with the correct uri', function() {

sinon.stub(workspace, 'open');

tabTracker.reveal();

assert.equal(workspace.open.callCount, 1);

assert.deepEqual(workspace.open.args[0], [

`atom-github://dock-item/${tabName}`,

{searchAllPanes: true, activateItem: true, activatePane: true},

]);

});

});

describe('hide', function() {

it('calls workspace.hide with the correct uri', function() {

sinon.stub(workspace, 'hide');

tabTracker.hide();

assert.equal(workspace.hide.callCount, 1);

assert.deepEqual(workspace.hide.args[0], [

`atom-github://dock-item/${tabName}`,

]);

});

});

describe('toggle()', function() {

it(`reveals the ${tabName} tab when item is not rendered`, async function() {

sinon.stub(tabTracker, 'reveal');

sinon.stub(tabTracker, 'isRendered').returns(false);

sinon.stub(tabTracker, 'isVisible').returns(false);

await tabTracker.toggle();

assert.equal(tabTracker.reveal.callCount, 1);

});

it(`reveals the ${tabName} tab when the item is rendered but not active`, async function() {

sinon.stub(tabTracker, 'reveal');

sinon.stub(tabTracker, 'isRendered').returns(true);

sinon.stub(tabTracker, 'isVisible').returns(false);

await tabTracker.toggle();

assert.equal(tabTracker.reveal.callCount, 1);

});

it(`hides the ${tabName} tab when open`, async function() {

sinon.stub(tabTracker, 'hide');

sinon.stub(tabTracker, 'isRendered').returns(true);

sinon.stub(tabTracker, 'isVisible').returns(true);

await tabTracker.toggle();

assert.equal(tabTracker.hide.callCount, 1);

});

});

describe('toggleFocus()', function() {

it(`reveals and focuses the ${tabName} tab when it is initially closed`, async function() {

sinon.stub(tabTracker, 'reveal');

sinon.stub(tabTracker, 'isRendered').returns(false);

sinon.stub(tabTracker, 'isVisible').returns(false);

sinon.stub(tabTracker, 'hasFocus').returns(false);

await tabTracker.toggleFocus();

assert.equal(tabTracker.reveal.callCount, 1);

assert.isTrue(tabTracker.focus.called);

assert.isFalse(workspace.getActivePane().activate.called);

});

it(`focuses the ${tabName} tab when it is already open, but blurred`, async function() {

sinon.stub(tabTracker, 'isRendered').returns(true);

sinon.stub(tabTracker, 'isVisible').returns(true);

sinon.stub(tabTracker, 'hasFocus').returns(false);

await tabTracker.toggleFocus();

assert.isTrue(tabTracker.focus.called);

assert.isFalse(workspace.getActivePane().activate.called);

});

it(`blurs the ${tabName} tab when it is already open and focused`, async function() {

sinon.stub(tabTracker, 'isRendered').returns(true);

sinon.stub(tabTracker, 'isVisible').returns(true);

sinon.stub(tabTracker, 'hasFocus').returns(true);

await tabTracker.toggleFocus();

assert.isFalse(tabTracker.focus.called);

assert.isTrue(workspace.getActivePane().activate.called);

});

});

describe('ensureVisible()', function() {

it(`reveals the ${tabName} tab when it is initially closed`, async function() {

sinon.stub(tabTracker, 'reveal');

sinon.stub(tabTracker, 'isRendered').returns(false);

sinon.stub(tabTracker, 'isVisible').returns(false);

assert.isTrue(await tabTracker.ensureVisible());

assert.equal(tabTracker.reveal.callCount, 1);

});

it(`does nothing when the ${tabName} tab is already open`, async function() {

sinon.stub(tabTracker, 'reveal');

sinon.stub(tabTracker, 'isRendered').returns(true);

sinon.stub(tabTracker, 'isVisible').returns(true);

assert.isFalse(await tabTracker.ensureVisible());

assert.equal(tabTracker.reveal.callCount, 0);

});

});

});

});

describe('initializeRepo', function() {

let createRepositoryForProjectPath, resolveInit, rejectInit;

beforeEach(function() {

createRepositoryForProjectPath = sinon.stub().returns(new Promise((resolve, reject) => {

resolveInit = resolve;

rejectInit = reject;

}));

});

it('renders the modal init panel', function() {

app = React.cloneElement(app, {createRepositoryForProjectPath});

const wrapper = shallow(app);

wrapper.instance().initializeRepo();

assert.lengthOf(wrapper.find('Panel').find({location: 'modal'}).find('InitDialog'), 1);

});

it('triggers the init callback on accept', function() {

app = React.cloneElement(app, {createRepositoryForProjectPath});

const wrapper = shallow(app);

wrapper.instance().initializeRepo();

const dialog = wrapper.find('InitDialog');

dialog.prop('didAccept')('/a/path');

resolveInit();

assert.isTrue(createRepositoryForProjectPath.calledWith('/a/path'));

});

it('dismisses the init callback on cancel', function() {

app = React.cloneElement(app, {createRepositoryForProjectPath});

const wrapper = shallow(app);

wrapper.instance().initializeRepo();

const dialog = wrapper.find('InitDialog');

dialog.prop('didCancel')();

assert.isFalse(wrapper.find('InitDialog').exists());

});

it('creates a notification if the init fails', async function() {

sinon.stub(notificationManager, 'addError');

app = React.cloneElement(app, {createRepositoryForProjectPath});

const wrapper = shallow(app);

wrapper.instance().initializeRepo();

const dialog = wrapper.find('InitDialog');

const acceptPromise = dialog.prop('didAccept')('/a/path');

const err = new GitError('git init exited with status 1');

err.stdErr = 'this is stderr';

rejectInit(err);

await acceptPromise;

assert.isFalse(wrapper.find('InitDialog').exists());

assert.isTrue(notificationManager.addError.calledWith(

'Unable to initialize git repository in /a/path',

sinon.match({detail: sinon.match(/this is stderr/)}),

));

});

});

describe('github:clone', function() {

let wrapper, cloneRepositoryForProjectPath, resolveClone, rejectClone;

beforeEach(function() {

cloneRepositoryForProjectPath = sinon.stub().returns(new Promise((resolve, reject) => {

resolveClone = resolve;

rejectClone = reject;

}));

app = React.cloneElement(app, {cloneRepositoryForProjectPath});

wrapper = shallow(app);

});

it('renders the modal clone panel', function() {

wrapper.instance().openCloneDialog();

assert.lengthOf(wrapper.find('Panel').find({location: 'modal'}).find('CloneDialog'), 1);

});

it('triggers the clone callback on accept', function() {

wrapper.instance().openCloneDialog();

const dialog = wrapper.find('CloneDialog');

dialog.prop('didAccept')('git@github.com:atom/github.git', '/home/me/github');

resolveClone();

assert.isTrue(cloneRepositoryForProjectPath.calledWith('git@github.com:atom/github.git', '/home/me/github'));

});

it('marks the clone dialog as in progress during clone', async function() {

wrapper.instance().openCloneDialog();

const dialog = wrapper.find('CloneDialog');

assert.isFalse(dialog.prop('inProgress'));

const acceptPromise = dialog.prop('didAccept')('git@github.com:atom/github.git', '/home/me/github');

assert.isTrue(wrapper.find('CloneDialog').prop('inProgress'));

resolveClone();

await acceptPromise;

assert.isFalse(wrapper.find('CloneDialog').exists());

});

it('creates a notification if the clone fails', async function() {

sinon.stub(notificationManager, 'addError');

wrapper.instance().openCloneDialog();

const dialog = wrapper.find('CloneDialog');

assert.isFalse(dialog.prop('inProgress'));

const acceptPromise = dialog.prop('didAccept')('git@github.com:nope/nope.git', '/home/me/github');

const err = new GitError('git clone exited with status 1');

err.stdErr = 'this is stderr';

rejectClone(err);

await acceptPromise;

assert.isFalse(wrapper.find('CloneDialog').exists());

assert.isTrue(notificationManager.addError.calledWith(

'Unable to clone git@github.com:nope/nope.git',

sinon.match({detail: sinon.match(/this is stderr/)}),

));

});

it('dismisses the clone panel on cancel', function() {

wrapper.instance().openCloneDialog();

const dialog = wrapper.find('CloneDialog');

dialog.prop('didCancel')();

assert.lengthOf(wrapper.find('CloneDialog'), 0);

assert.isFalse(cloneRepositoryForProjectPath.called);

});

});

describe('promptForCredentials()', function() {

let wrapper;

beforeEach(function() {

wrapper = shallow(app);

});

it('renders the modal credentials dialog', function() {

wrapper.instance().promptForCredentials({

prompt: 'Password plz',

includeUsername: true,

});

const dialog = wrapper.find('Panel').find({location: 'modal'}).find('CredentialDialog');

assert.isTrue(dialog.exists());

assert.equal(dialog.prop('prompt'), 'Password plz');

assert.isTrue(dialog.prop('includeUsername'));

});

it('resolves the promise with credentials on accept', async function() {

const credentialPromise = wrapper.instance().promptForCredentials({

prompt: 'Speak "friend" and enter',

includeUsername: false,

});

wrapper.find('CredentialDialog').prop('onSubmit')({password: 'friend'});

assert.deepEqual(await credentialPromise, {password: 'friend'});

assert.isFalse(wrapper.find('CredentialDialog').exists());

});

it('rejects the promise on cancel', async function() {

const credentialPromise = wrapper.instance().promptForCredentials({

prompt: 'Enter the square root of 1244313452349528345',

includeUsername: false,

});

wrapper.find('CredentialDialog').prop('onCancel')();

await assert.isRejected(credentialPromise);

assert.isFalse(wrapper.find('CredentialDialog').exists());

});

});

describe('openFiles(filePaths)', () => {

it('calls workspace.open, passing pending:true if only one file path is passed', async () => {

const workdirPath = await cloneRepository('three-files');

const repository = await buildRepository(workdirPath);

fs.writeFileSync(path.join(workdirPath, 'file1.txt'), 'foo');

fs.writeFileSync(path.join(workdirPath, 'file2.txt'), 'bar');

fs.writeFileSync(path.join(workdirPath, 'file3.txt'), 'baz');

sinon.stub(workspace, 'open');

app = React.cloneElement(app, {repository});

const wrapper = shallow(app);

await wrapper.instance().openFiles(['file1.txt']);

assert.equal(workspace.open.callCount, 1);

assert.deepEqual(workspace.open.args[0], [path.join(repository.getWorkingDirectoryPath(), 'file1.txt'), {pending: true}]);

workspace.open.reset();

await wrapper.instance().openFiles(['file2.txt', 'file3.txt']);

assert.equal(workspace.open.callCount, 2);

assert.deepEqual(workspace.open.args[0], [path.join(repository.getWorkingDirectoryPath(), 'file2.txt'), {pending: false}]);

assert.deepEqual(workspace.open.args[1], [path.join(repository.getWorkingDirectoryPath(), 'file3.txt'), {pending: false}]);

});

});

describe('discarding and restoring changed lines', () => {

describe('discardLines(filePatch, lines)', () => {

it('only discards lines if buffer is unmodified, otherwise notifies user', async () => {

const workdirPath = await cloneRepository('three-files');

const repository = await buildRepository(workdirPath);

fs.writeFileSync(path.join(workdirPath, 'a.txt'), 'modification\n');

const unstagedFilePatch = await repository.getFilePatchForPath('a.txt');

const editor = await workspace.open(path.join(workdirPath, 'a.txt'));

app = React.cloneElement(app, {repository});

const wrapper = shallow(app);

const state = {

filePath: 'a.txt',

filePatch: unstagedFilePatch,

stagingStatus: 'unstaged',

};

wrapper.setState(state);

sinon.stub(repository, 'applyPatchToWorkdir');

sinon.stub(notificationManager, 'addError');

// unmodified buffer

const hunkLines = unstagedFilePatch.getHunks()[0].getLines();

await wrapper.instance().discardLines(unstagedFilePatch, new Set([hunkLines[0]]));

assert.isTrue(repository.applyPatchToWorkdir.calledOnce);

assert.isFalse(notificationManager.addError.called);

// modified buffer

repository.applyPatchToWorkdir.reset();

editor.setText('modify contents');

await wrapper.instance().discardLines(unstagedFilePatch, new Set(unstagedFilePatch.getHunks()[0].getLines()));

assert.isFalse(repository.applyPatchToWorkdir.called);

const notificationArgs = notificationManager.addError.args[0];

assert.equal(notificationArgs[0], 'Cannot discard lines.');

assert.match(notificationArgs[1].description, /You have unsaved changes in/);

});

});

describe('discardWorkDirChangesForPaths(filePaths)', () => {

it('only discards changes in files if all buffers are unmodified, otherwise notifies user', async () => {

const workdirPath = await cloneRepository('three-files');

const repository = await buildRepository(workdirPath);

fs.writeFileSync(path.join(workdirPath, 'a.txt'), 'do\n');

fs.writeFileSync(path.join(workdirPath, 'b.txt'), 'ray\n');

fs.writeFileSync(path.join(workdirPath, 'c.txt'), 'me\n');

const editor = await workspace.open(path.join(workdirPath, 'a.txt'));

app = React.cloneElement(app, {repository});

const wrapper = shallow(app);

sinon.stub(repository, 'discardWorkDirChangesForPaths');

sinon.stub(notificationManager, 'addError');

// unmodified buffer

await wrapper.instance().discardWorkDirChangesForPaths(['a.txt', 'b.txt', 'c.txt']);

assert.isTrue(repository.discardWorkDirChangesForPaths.calledOnce);

assert.isFalse(notificationManager.addError.called);

// modified buffer

repository.discardWorkDirChangesForPaths.reset();

editor.setText('modify contents');

await wrapper.instance().discardWorkDirChangesForPaths(['a.txt', 'b.txt', 'c.txt']);

assert.isFalse(repository.discardWorkDirChangesForPaths.called);

const notificationArgs = notificationManager.addError.args[0];

assert.equal(notificationArgs[0], 'Cannot discard changes in selected files.');

assert.match(notificationArgs[1].description, /You have unsaved changes in.*a\.txt/);

});

});

describe('undoLastDiscard(partialDiscardFilePath)', () => {

describe('when partialDiscardFilePath is not null', () => {

let unstagedFilePatch, repository, absFilePath, wrapper;

beforeEach(async () => {

const workdirPath = await cloneRepository('multi-line-file');

repository = await buildRepository(workdirPath);

absFilePath = path.join(workdirPath, 'sample.js');

fs.writeFileSync(absFilePath, 'foo\nbar\nbaz\n');

unstagedFilePatch = await repository.getFilePatchForPath('sample.js');

app = React.cloneElement(app, {repository});

wrapper = shallow(app);

wrapper.setState({

filePath: 'sample.js',

filePatch: unstagedFilePatch,

stagingStatus: 'unstaged',

});

});

it('reverses last discard for file path', async () => {

const contents1 = fs.readFileSync(absFilePath, 'utf8');

await wrapper.instance().discardLines(unstagedFilePatch, new Set(unstagedFilePatch.getHunks()[0].getLines().slice(0, 2)));

const contents2 = fs.readFileSync(absFilePath, 'utf8');

assert.notEqual(contents1, contents2);

await repository.refresh();

unstagedFilePatch = await repository.getFilePatchForPath('sample.js');

wrapper.setState({filePatch: unstagedFilePatch});

await wrapper.instance().discardLines(unstagedFilePatch, new Set(unstagedFilePatch.getHunks()[0].getLines().slice(2, 4)));

const contents3 = fs.readFileSync(absFilePath, 'utf8');

assert.notEqual(contents2, contents3);

await wrapper.instance().undoLastDiscard('sample.js');

await assert.async.equal(fs.readFileSync(absFilePath, 'utf8'), contents2);

await wrapper.instance().undoLastDiscard('sample.js');

await assert.async.equal(fs.readFileSync(absFilePath, 'utf8'), contents1);

});

it('does not undo if buffer is modified', async () => {

const contents1 = fs.readFileSync(absFilePath, 'utf8');

await wrapper.instance().discardLines(unstagedFilePatch, new Set(unstagedFilePatch.getHunks()[0].getLines().slice(0, 2)));

const contents2 = fs.readFileSync(absFilePath, 'utf8');

assert.notEqual(contents1, contents2);

// modify buffer

const editor = await workspace.open(absFilePath);

editor.getBuffer().append('new line');

const expandBlobToFile = sinon.spy(repository, 'expandBlobToFile');

sinon.stub(notificationManager, 'addError');

await repository.refresh();

unstagedFilePatch = await repository.getFilePatchForPath('sample.js');

wrapper.setState({filePatch: unstagedFilePatch});

await wrapper.instance().undoLastDiscard('sample.js');

const notificationArgs = notificationManager.addError.args[0];

assert.equal(notificationArgs[0], 'Cannot undo last discard.');

assert.match(notificationArgs[1].description, /You have unsaved changes./);