mirror of
https://github.com/pulsar-edit/pulsar.git
synced 2024-09-11 19:17:09 +03:00
448 lines
14 KiB
JavaScript
448 lines
14 KiB
JavaScript
const path = require('path');
|
|
const fs = require('fs-plus');
|
|
const temp = require('temp').track();
|
|
const GitRepository = require('../src/git-repository');
|
|
const Project = require('../src/project');
|
|
|
|
describe('GitRepository', () => {
|
|
let repo;
|
|
|
|
beforeEach(() => {
|
|
const gitPath = path.join(temp.dir, '.git');
|
|
if (fs.isDirectorySync(gitPath)) fs.removeSync(gitPath);
|
|
});
|
|
|
|
afterEach(() => {
|
|
if (repo && !repo.isDestroyed()) repo.destroy();
|
|
});
|
|
|
|
describe('@open(path)', () => {
|
|
it('returns null when no repository is found', () => {
|
|
expect(GitRepository.open(path.join(temp.dir, 'nogit.txt'))).toBeNull();
|
|
});
|
|
});
|
|
|
|
describe('new GitRepository(path)', () => {
|
|
it('throws an exception when no repository is found', () => {
|
|
expect(
|
|
() => new GitRepository(path.join(temp.dir, 'nogit.txt'))
|
|
).toThrow();
|
|
});
|
|
});
|
|
|
|
describe('.getPath()', () => {
|
|
it('returns the repository path for a .git directory path with a directory', () => {
|
|
repo = new GitRepository(
|
|
path.join(__dirname, 'fixtures', 'git', 'master.git', 'objects')
|
|
);
|
|
expect(repo.getPath()).toBe(
|
|
path.join(__dirname, 'fixtures', 'git', 'master.git')
|
|
);
|
|
});
|
|
|
|
it('returns the repository path for a repository path', () => {
|
|
repo = new GitRepository(
|
|
path.join(__dirname, 'fixtures', 'git', 'master.git')
|
|
);
|
|
expect(repo.getPath()).toBe(
|
|
path.join(__dirname, 'fixtures', 'git', 'master.git')
|
|
);
|
|
});
|
|
});
|
|
|
|
describe('.isPathIgnored(path)', () => {
|
|
it('returns true for an ignored path', () => {
|
|
repo = new GitRepository(
|
|
path.join(__dirname, 'fixtures', 'git', 'ignore.git')
|
|
);
|
|
expect(repo.isPathIgnored('a.txt')).toBeTruthy();
|
|
});
|
|
|
|
it('returns false for a non-ignored path', () => {
|
|
repo = new GitRepository(
|
|
path.join(__dirname, 'fixtures', 'git', 'ignore.git')
|
|
);
|
|
expect(repo.isPathIgnored('b.txt')).toBeFalsy();
|
|
});
|
|
});
|
|
|
|
describe('.isPathModified(path)', () => {
|
|
let filePath, newPath;
|
|
|
|
beforeEach(() => {
|
|
const workingDirPath = copyRepository();
|
|
repo = new GitRepository(workingDirPath);
|
|
filePath = path.join(workingDirPath, 'a.txt');
|
|
newPath = path.join(workingDirPath, 'new-path.txt');
|
|
});
|
|
|
|
describe('when the path is unstaged', () => {
|
|
it('returns false if the path has not been modified', () => {
|
|
expect(repo.isPathModified(filePath)).toBeFalsy();
|
|
});
|
|
|
|
it('returns true if the path is modified', () => {
|
|
fs.writeFileSync(filePath, 'change');
|
|
expect(repo.isPathModified(filePath)).toBeTruthy();
|
|
});
|
|
|
|
it('returns true if the path is deleted', () => {
|
|
fs.removeSync(filePath);
|
|
expect(repo.isPathModified(filePath)).toBeTruthy();
|
|
});
|
|
|
|
it('returns false if the path is new', () => {
|
|
expect(repo.isPathModified(newPath)).toBeFalsy();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('.isPathNew(path)', () => {
|
|
let filePath, newPath;
|
|
|
|
beforeEach(() => {
|
|
const workingDirPath = copyRepository();
|
|
repo = new GitRepository(workingDirPath);
|
|
filePath = path.join(workingDirPath, 'a.txt');
|
|
newPath = path.join(workingDirPath, 'new-path.txt');
|
|
fs.writeFileSync(newPath, "i'm new here");
|
|
});
|
|
|
|
describe('when the path is unstaged', () => {
|
|
it('returns true if the path is new', () => {
|
|
expect(repo.isPathNew(newPath)).toBeTruthy();
|
|
});
|
|
|
|
it("returns false if the path isn't new", () => {
|
|
expect(repo.isPathNew(filePath)).toBeFalsy();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('.checkoutHead(path)', () => {
|
|
let filePath;
|
|
|
|
beforeEach(() => {
|
|
const workingDirPath = copyRepository();
|
|
repo = new GitRepository(workingDirPath);
|
|
filePath = path.join(workingDirPath, 'a.txt');
|
|
});
|
|
|
|
it('no longer reports a path as modified after checkout', () => {
|
|
expect(repo.isPathModified(filePath)).toBeFalsy();
|
|
fs.writeFileSync(filePath, 'ch ch changes');
|
|
expect(repo.isPathModified(filePath)).toBeTruthy();
|
|
expect(repo.checkoutHead(filePath)).toBeTruthy();
|
|
expect(repo.isPathModified(filePath)).toBeFalsy();
|
|
});
|
|
|
|
it('restores the contents of the path to the original text', () => {
|
|
fs.writeFileSync(filePath, 'ch ch changes');
|
|
expect(repo.checkoutHead(filePath)).toBeTruthy();
|
|
expect(fs.readFileSync(filePath, 'utf8')).toBe('');
|
|
});
|
|
|
|
it('fires a status-changed event if the checkout completes successfully', () => {
|
|
fs.writeFileSync(filePath, 'ch ch changes');
|
|
repo.getPathStatus(filePath);
|
|
const statusHandler = jasmine.createSpy('statusHandler');
|
|
repo.onDidChangeStatus(statusHandler);
|
|
repo.checkoutHead(filePath);
|
|
expect(statusHandler.callCount).toBe(1);
|
|
expect(statusHandler.argsForCall[0][0]).toEqual({
|
|
path: filePath,
|
|
pathStatus: 0
|
|
});
|
|
|
|
repo.checkoutHead(filePath);
|
|
expect(statusHandler.callCount).toBe(1);
|
|
});
|
|
});
|
|
|
|
describe('.checkoutHeadForEditor(editor)', () => {
|
|
let filePath, editor;
|
|
|
|
beforeEach(async () => {
|
|
spyOn(atom, 'confirm');
|
|
|
|
const workingDirPath = copyRepository();
|
|
repo = new GitRepository(workingDirPath, {
|
|
project: atom.project,
|
|
config: atom.config,
|
|
confirm: atom.confirm
|
|
});
|
|
filePath = path.join(workingDirPath, 'a.txt');
|
|
fs.writeFileSync(filePath, 'ch ch changes');
|
|
|
|
editor = await atom.workspace.open(filePath);
|
|
});
|
|
|
|
it('displays a confirmation dialog by default', () => {
|
|
// Permissions issues with this test on Windows
|
|
if (process.platform === 'win32') return;
|
|
|
|
atom.confirm.andCallFake(({ buttons }) => buttons.OK());
|
|
atom.config.set('editor.confirmCheckoutHeadRevision', true);
|
|
|
|
repo.checkoutHeadForEditor(editor);
|
|
|
|
expect(fs.readFileSync(filePath, 'utf8')).toBe('');
|
|
});
|
|
|
|
it('does not display a dialog when confirmation is disabled', () => {
|
|
// Flakey EPERM opening a.txt on Win32
|
|
if (process.platform === 'win32') return;
|
|
atom.config.set('editor.confirmCheckoutHeadRevision', false);
|
|
|
|
repo.checkoutHeadForEditor(editor);
|
|
|
|
expect(fs.readFileSync(filePath, 'utf8')).toBe('');
|
|
expect(atom.confirm).not.toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
describe('.destroy()', () => {
|
|
it('throws an exception when any method is called after it is called', () => {
|
|
repo = new GitRepository(
|
|
path.join(__dirname, 'fixtures', 'git', 'master.git')
|
|
);
|
|
repo.destroy();
|
|
expect(() => repo.getShortHead()).toThrow();
|
|
});
|
|
});
|
|
|
|
describe('.getPathStatus(path)', () => {
|
|
let filePath;
|
|
|
|
beforeEach(() => {
|
|
const workingDirectory = copyRepository();
|
|
repo = new GitRepository(workingDirectory);
|
|
filePath = path.join(workingDirectory, 'file.txt');
|
|
});
|
|
|
|
it('trigger a status-changed event when the new status differs from the last cached one', () => {
|
|
const statusHandler = jasmine.createSpy('statusHandler');
|
|
repo.onDidChangeStatus(statusHandler);
|
|
fs.writeFileSync(filePath, '');
|
|
let status = repo.getPathStatus(filePath);
|
|
expect(statusHandler.callCount).toBe(1);
|
|
expect(statusHandler.argsForCall[0][0]).toEqual({
|
|
path: filePath,
|
|
pathStatus: status
|
|
});
|
|
|
|
fs.writeFileSync(filePath, 'abc');
|
|
status = repo.getPathStatus(filePath);
|
|
expect(statusHandler.callCount).toBe(1);
|
|
});
|
|
});
|
|
|
|
describe('.getDirectoryStatus(path)', () => {
|
|
let directoryPath, filePath;
|
|
|
|
beforeEach(() => {
|
|
const workingDirectory = copyRepository();
|
|
repo = new GitRepository(workingDirectory);
|
|
directoryPath = path.join(workingDirectory, 'dir');
|
|
filePath = path.join(directoryPath, 'b.txt');
|
|
});
|
|
|
|
it('gets the status based on the files inside the directory', () => {
|
|
expect(
|
|
repo.isStatusModified(repo.getDirectoryStatus(directoryPath))
|
|
).toBe(false);
|
|
fs.writeFileSync(filePath, 'abc');
|
|
repo.getPathStatus(filePath);
|
|
expect(
|
|
repo.isStatusModified(repo.getDirectoryStatus(directoryPath))
|
|
).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe('.refreshStatus()', () => {
|
|
let newPath, modifiedPath, cleanPath, workingDirectory;
|
|
|
|
beforeEach(() => {
|
|
workingDirectory = copyRepository();
|
|
repo = new GitRepository(workingDirectory, {
|
|
project: atom.project,
|
|
config: atom.config
|
|
});
|
|
modifiedPath = path.join(workingDirectory, 'file.txt');
|
|
newPath = path.join(workingDirectory, 'untracked.txt');
|
|
cleanPath = path.join(workingDirectory, 'other.txt');
|
|
fs.writeFileSync(cleanPath, 'Full of text');
|
|
fs.writeFileSync(newPath, '');
|
|
newPath = fs.absolute(newPath);
|
|
});
|
|
|
|
it('returns status information for all new and modified files', async () => {
|
|
const statusHandler = jasmine.createSpy('statusHandler');
|
|
repo.onDidChangeStatuses(statusHandler);
|
|
fs.writeFileSync(modifiedPath, 'making this path modified');
|
|
|
|
await repo.refreshStatus();
|
|
expect(statusHandler.callCount).toBe(1);
|
|
expect(repo.getCachedPathStatus(cleanPath)).toBeUndefined();
|
|
expect(repo.isStatusNew(repo.getCachedPathStatus(newPath))).toBeTruthy();
|
|
expect(
|
|
repo.isStatusModified(repo.getCachedPathStatus(modifiedPath))
|
|
).toBeTruthy();
|
|
});
|
|
|
|
it('caches the proper statuses when a subdir is open', async () => {
|
|
const subDir = path.join(workingDirectory, 'dir');
|
|
fs.mkdirSync(subDir);
|
|
const filePath = path.join(subDir, 'b.txt');
|
|
fs.writeFileSync(filePath, '');
|
|
atom.project.setPaths([subDir]);
|
|
await atom.workspace.open('b.txt');
|
|
repo = atom.project.getRepositories()[0];
|
|
|
|
await repo.refreshStatus();
|
|
const status = repo.getCachedPathStatus(filePath);
|
|
expect(repo.isStatusModified(status)).toBe(false);
|
|
expect(repo.isStatusNew(status)).toBe(false);
|
|
});
|
|
|
|
it('works correctly when the project has multiple folders (regression)', async () => {
|
|
atom.project.addPath(workingDirectory);
|
|
atom.project.addPath(path.join(__dirname, 'fixtures', 'dir'));
|
|
|
|
await repo.refreshStatus();
|
|
expect(repo.getCachedPathStatus(cleanPath)).toBeUndefined();
|
|
expect(repo.isStatusNew(repo.getCachedPathStatus(newPath))).toBeTruthy();
|
|
expect(
|
|
repo.isStatusModified(repo.getCachedPathStatus(modifiedPath))
|
|
).toBeTruthy();
|
|
});
|
|
|
|
it('caches statuses that were looked up synchronously', async () => {
|
|
const originalContent = 'undefined';
|
|
fs.writeFileSync(modifiedPath, 'making this path modified');
|
|
repo.getPathStatus('file.txt');
|
|
|
|
fs.writeFileSync(modifiedPath, originalContent);
|
|
await repo.refreshStatus();
|
|
expect(
|
|
repo.isStatusModified(repo.getCachedPathStatus(modifiedPath))
|
|
).toBeFalsy();
|
|
});
|
|
});
|
|
|
|
describe('buffer events', () => {
|
|
let editor;
|
|
|
|
beforeEach(async () => {
|
|
atom.project.setPaths([copyRepository()]);
|
|
const refreshPromise = new Promise(resolve =>
|
|
atom.project.getRepositories()[0].onDidChangeStatuses(resolve)
|
|
);
|
|
editor = await atom.workspace.open('other.txt');
|
|
await refreshPromise;
|
|
});
|
|
|
|
it('emits a status-changed event when a buffer is saved', async () => {
|
|
editor.insertNewline();
|
|
|
|
const statusHandler = jasmine.createSpy('statusHandler');
|
|
atom.project.getRepositories()[0].onDidChangeStatus(statusHandler);
|
|
|
|
await editor.save();
|
|
expect(statusHandler.callCount).toBe(1);
|
|
expect(statusHandler).toHaveBeenCalledWith({
|
|
path: editor.getPath(),
|
|
pathStatus: 256
|
|
});
|
|
});
|
|
|
|
it('emits a status-changed event when a buffer is reloaded', async () => {
|
|
fs.writeFileSync(editor.getPath(), 'changed');
|
|
|
|
const statusHandler = jasmine.createSpy('statusHandler');
|
|
atom.project.getRepositories()[0].onDidChangeStatus(statusHandler);
|
|
|
|
await editor.getBuffer().reload();
|
|
expect(statusHandler.callCount).toBe(1);
|
|
expect(statusHandler).toHaveBeenCalledWith({
|
|
path: editor.getPath(),
|
|
pathStatus: 256
|
|
});
|
|
|
|
await editor.getBuffer().reload();
|
|
expect(statusHandler.callCount).toBe(1);
|
|
});
|
|
|
|
it("emits a status-changed event when a buffer's path changes", () => {
|
|
fs.writeFileSync(editor.getPath(), 'changed');
|
|
|
|
const statusHandler = jasmine.createSpy('statusHandler');
|
|
atom.project.getRepositories()[0].onDidChangeStatus(statusHandler);
|
|
editor.getBuffer().emitter.emit('did-change-path');
|
|
expect(statusHandler.callCount).toBe(1);
|
|
expect(statusHandler).toHaveBeenCalledWith({
|
|
path: editor.getPath(),
|
|
pathStatus: 256
|
|
});
|
|
editor.getBuffer().emitter.emit('did-change-path');
|
|
expect(statusHandler.callCount).toBe(1);
|
|
});
|
|
|
|
it('stops listening to the buffer when the repository is destroyed (regression)', () => {
|
|
atom.project.getRepositories()[0].destroy();
|
|
expect(() => editor.save()).not.toThrow();
|
|
});
|
|
});
|
|
|
|
describe('when a project is deserialized', () => {
|
|
let buffer, project2, statusHandler;
|
|
|
|
afterEach(() => {
|
|
if (project2) project2.destroy();
|
|
});
|
|
|
|
it('subscribes to all the serialized buffers in the project', async () => {
|
|
atom.project.setPaths([copyRepository()]);
|
|
|
|
await atom.workspace.open('file.txt');
|
|
|
|
project2 = new Project({
|
|
notificationManager: atom.notifications,
|
|
packageManager: atom.packages,
|
|
confirm: atom.confirm,
|
|
grammarRegistry: atom.grammars,
|
|
applicationDelegate: atom.applicationDelegate
|
|
});
|
|
await project2.deserialize(
|
|
atom.project.serialize({ isUnloading: false })
|
|
);
|
|
|
|
buffer = project2.getBuffers()[0];
|
|
buffer.append('changes');
|
|
|
|
statusHandler = jasmine.createSpy('statusHandler');
|
|
project2.getRepositories()[0].onDidChangeStatus(statusHandler);
|
|
await buffer.save();
|
|
|
|
expect(statusHandler.callCount).toBe(1);
|
|
expect(statusHandler).toHaveBeenCalledWith({
|
|
path: buffer.getPath(),
|
|
pathStatus: 256
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
function copyRepository() {
|
|
const workingDirPath = temp.mkdirSync('atom-spec-git');
|
|
fs.copySync(
|
|
path.join(__dirname, 'fixtures', 'git', 'working-dir'),
|
|
workingDirPath
|
|
);
|
|
fs.renameSync(
|
|
path.join(workingDirPath, 'git.git'),
|
|
path.join(workingDirPath, '.git')
|
|
);
|
|
return workingDirPath;
|
|
}
|