define(function (require, exports, module) {

"use strict";

var ProjectModel = require("project/ProjectModel"),

Immutable = require("thirdparty/immutable");

describe("ProjectModel", function () {

describe("shouldShow", function () {

it("returns true for names that should be shown", function () {

expect(ProjectModel.shouldShow({

name: "test.js"

})).toBe(true);

});

it("returns false for names that should not be shown", function () {

expect(ProjectModel.shouldShow({

name: ".git"

})).toBe(false);

});

});

describe("_ensureTrailingSlash", function () {

it("adds a slash when there is none", function () {

expect(ProjectModel._ensureTrailingSlash("/foo/bar")).toBe("/foo/bar/");

});

it("does nothing when there is already a slash", function () {

expect(ProjectModel._ensureTrailingSlash("/foo/bar/")).toBe("/foo/bar/");

});

});

it("should start with null projectRoot", function () {

var pm = new ProjectModel.ProjectModel();

expect(pm.projectRoot).toBe(null);

});

describe("with projectRoot", function () {

var root, pm;

beforeEach(function () {

root = {

fullPath: "/foo/bar/project/"

};

pm = new ProjectModel.ProjectModel({

projectRoot: root

});

});

it("allows setting projectRoot on construction", function () {

expect(pm.projectRoot).toBe(root);

});

it("can tell you if a file is in a project", function () {

var file = {

fullPath: "/foo/bar/project/README.md"

};

expect(pm.isWithinProject(file)).toBe(true);

});

it("can tell you if a file is not in a project", function () {

var file = {

fullPath: "/some/other/project/README.md"

};

expect(pm.isWithinProject(file)).toBe(false);

});

it("can make a file project relative", function () {

expect(pm.makeProjectRelativeIfPossible("/foo/bar/project/README.md")).toBe("README.md");

});

it("won't create a relative path to a file outside the project", function () {

expect(pm.makeProjectRelativeIfPossible("/some/other/project/README.md")).toBe("/some/other/project/README.md");

});

it("will return a directory within the project", function () {

expect(pm.getDirectoryInProject("/foo/bar/project/baz/")).toBe("/foo/bar/project/baz/");

expect(pm.getDirectoryInProject("/foo/bar/project/baz")).toBe("/foo/bar/project/baz/");

expect(pm.getDirectoryInProject({

fullPath: "/foo/bar/project/foo2/",

isDirectory: true

})).toBe("/foo/bar/project/foo2/");

});

it("will default to project root when getDirectoryInProject", function () {

expect(pm.getDirectoryInProject()).toBe("/foo/bar/project/");

expect(pm.getDirectoryInProject(null)).toBe("/foo/bar/project/");

expect(pm.getDirectoryInProject("")).toBe("/foo/bar/project/");

expect(pm.getDirectoryInProject({

isFile: true,

isDirectory: false,

fullPath: "/foo/bar/project/README.txt"

})).toBe("/foo/bar/project/");

expect(pm.getDirectoryInProject("/other/project/")).toBe("/foo/bar/project/");

});

});

describe("All Files Cache", function () {

var visited = false;

function getPM(filelist, error, rootPath) {

}

beforeEach(function () {

visited = false;

});

it("can create a list of all files", function () {

var pm = getPM([{

fullPath: "/README.md",

name: "README.md",

isFile: true

}, {

fullPath: "/other/",

name: "other",

isFile: false

}, {

fullPath: "/other/test.js",

name: "test.js",

isFile: true

}]);

pm.getAllFiles().then(function (allFiles) {

expect(allFiles.length).toBe(2);

expect(allFiles).toContain("/README.md");

});

});

it("filters files that don't pass shouldShow", function () {

var pm = getPM([

{

fullPath: "/setup.pyc",

name: "setup.pyc",

isFile: true

}

]);

pm.getAllFiles().then(function (allFiles) {

expect(allFiles.length).toBe(0);

});

});

it("rejects the promise when there's an error", function () {

var pm = getPM(null, "Got An Error");

pm.getAllFiles().then(function (allFiles) {

expect("should not have gotten here").toBe("because there should be an error");

}, function (error) {

expect(error).toBe("Got An Error");

});

});

it("filters the file list with a function, if desired", function () {

var pm = getPM([

{

fullPath: "/README.md",

name: "README.md",

isFile: true

}, {

fullPath: "/test.js",

name: "test.js",

isFile: true

}

]);

pm.getAllFiles(function (entry) {

return entry.name === "test.js";

}).then(function (allFiles) {

expect(allFiles.length).toBe(1);

expect(allFiles).toContain("/test.js");

});

});

it("can add additional non-project files to the list", function () {

var pm = getPM([

{

fullPath: "/project/README.md",

name: "README.md",

isFile: true

}

], null, "/project");

pm.getAllFiles([{

fullPath: "/project/otherProjectFile.js"

}, {

fullPath: "/RootFile.txt"

}]).then(function (allFiles) {

expect(allFiles.length).toBe(2);

expect(allFiles).toContain("/project/README.md");

expect(allFiles).toContain("/RootFile.txt");

});

});

it("caches the all files list", function () {

var pm = getPM([

{

fullPath: "/project/README.md",

name: "README.md",

isFile: true

}

]);

pm.getAllFiles().then(function (allFiles) {

expect(visited).toBe(true);

visited = false;

pm.getAllFiles().then(function (allFiles) {

expect(visited).toBe(false);

});

});

});

it("can reset the cache", function () {

var pm = getPM([

{

fullPath: "/project/README.md",

name: "README.md",

isFile: true

}

]);

pm.getAllFiles().then(function (allFiles) {

expect(visited).toBe(true);

visited = false;

pm._resetCache();

pm.getAllFiles().then(function (allFiles) {

expect(visited).toBe(true);

});

});

});

});

describe("_getWelcomeProjectPath", function () {

it("returns the initial directory if there's no sample URL", function () {

expect(ProjectModel._getWelcomeProjectPath(undefined, "/Brackets/")).toBe("/Brackets/");

});

it("returns the correct sample directory", function () {

expect(ProjectModel._getWelcomeProjectPath("root/GettingStarted/", "/Brackets/")).toBe(

"/Brackets/samples/root/GettingStarted/"

);

});

it("ensures there's a trailing slash for backwards compatibility", function () {

expect(ProjectModel._getWelcomeProjectPath("root/GettingStarted", "/Brackets/")).toBe(

"/Brackets/samples/root/GettingStarted/"

);

});

});

describe("_addWelcomeProjectPath", function () {

it("adds the path to a new array", function () {

var currentProjects = ["GettingStarted"];

var newProjects = ProjectModel._addWelcomeProjectPath("NewStart/", currentProjects);

expect(currentProjects.length).toBe(1);

expect(newProjects).toEqual(["GettingStarted", "NewStart"]);

});

});

describe("_isWelcomeProjectPath", function () {

it("matches on the current welcome project", function () {

expect(ProjectModel._isWelcomeProjectPath("/Brackets/GettingStarted/", "/Brackets/GettingStarted/")).toBe(true);

});

it("matches on previous welcome projects", function () {

expect(ProjectModel._isWelcomeProjectPath("/Brackets/GettingStarted/", "/Brackets/NewStart/",

["/Brackets/GettingStarted"])).toBe(true);

});

it("returns false when there's no match", function () {

expect(ProjectModel._isWelcomeProjectPath("/Brackets/Unknown/", "/Brackets/NewStart/",

["/Brackets/GettingStarted"])).toBe(false);

});

it("returns false when the project doesn't match and there are no known projects", function () {

expect(ProjectModel._isWelcomeProjectPath("/Brackets/Unknown/", "/Brackets/NewStart/")).toBe(false);

});

});

describe("isValidPath", function () {

it("returns true for UNIX style file path", function () {

expect(ProjectModel.isValidPath("/tmp/src/test/")).toBe(true);

});

it("returns true for WINDOWS style file path", function () {

expect(ProjectModel.isValidPath("C:\\tmp\\src\\test\\")).toBe(true);

});

it("returns false for path that contains an invalid char \'..\'", function () {

expect(ProjectModel.isValidPath("../tmp/src/test/")).toBe(false);

});

it("returns false for path that contains an invalid char \'../..\'", function () {

expect(ProjectModel.isValidPath("../../tmp/src/test/")).toBe(false);

});

it("returns false for path that contains an invalid char \'..\\..\'", function () {

expect(ProjectModel.isValidPath("..\\..\\tmp\\src\\test\\")).toBe(false);

});

});

describe("isValidFilename", function () {

it("returns true for simple filename", function () {

expect(ProjectModel.isValidFilename("foo.txt")).toBe(true);

});

it("returns true for filename that starts with a '\.\'", function () {

expect(ProjectModel.isValidFilename(".tmp")).toBe(true);

});

it("returns false for filenames that has ends with a \'.\'", function () {

expect(ProjectModel.isValidFilename("dummy.")).toBe(false);

});

it("returns false for filename that contains an invalid char \'?\'", function () {

expect(ProjectModel.isValidFilename("foo?txt")).toBe(false);

});

it("returns false for filename that contains an invalid char \'*\'", function () {

expect(ProjectModel.isValidFilename("foo\*txt")).toBe(false);

});

it("returns false for filename that contains an invalid char \'\|\'", function () {

expect(ProjectModel.isValidFilename("foo\|txt")).toBe(false);

});

it("returns false for filename that contains an invalid char \'\:\'", function () {

expect(ProjectModel.isValidFilename("foo\:txt")).toBe(false);

});

it("returns false for filename that contains an invalid char \'\<\'", function () {

expect(ProjectModel.isValidFilename("foo\<txt")).toBe(false);

});

it("returns false for filename that contains an invalid char \'\>\'", function () {

expect(ProjectModel.isValidFilename("foo\>txt")).toBe(false);

});

it("returns false for filename that contains an invalid char \'/\'", function () {

expect(ProjectModel.isValidFilename("directory/foo.txt")).toBe(false);

});

it("returns false for filename that contains an invalid char \'//\'", function () {

expect(ProjectModel.isValidFilename("directory//foo.txt")).toBe(false);

});

it("returns false for filename that contains an invalid char \'\\\'", function () {

expect(ProjectModel.isValidFilename("directory\\foo.txt")).toBe(false);

});

it("returns false for filename that contains an invalid char \'\\\\\'", function () {

expect(ProjectModel.isValidFilename("directory\\\\foo.txt")).toBe(false);

});

it("returns false for filename that contains an invalid char \'..\'", function () {

expect(ProjectModel.isValidFilename("..foo")).toBe(false);

});

it("returns false for filename that contains an invalid char \'..\\..\'", function () {

expect(ProjectModel.isValidFilename("..\\foo")).toBe(false);

});

it("returns false for filenames that has invalid name \'com1\'", function () {

expect(ProjectModel.isValidFilename("com1")).toBe(false);

});

it("returns false for filenames that has invalid name \'lpt\'", function () {

expect(ProjectModel.isValidFilename("lpt1")).toBe(false);

});

it("returns false for filenames that has invalid name \'nul\'", function () {

expect(ProjectModel.isValidFilename("nul")).toBe(false);

});

it("returns false for filenames that has invalid name \'con\'", function () {

expect(ProjectModel.isValidFilename("con")).toBe(false);

});

it("returns false for filenames that has invalid name \'prn\'", function () {

expect(ProjectModel.isValidFilename("prn")).toBe(false);

});

it("returns false for filenames that has invalid name \'aux\'", function () {

expect(ProjectModel.isValidFilename("aux")).toBe(false);

});

});

describe("setProjectRoot", function () {

var subdir = {

fullPath: "/path/to/project/subdir/",

name: "subdir",

isFile: false

},

contents = [

{

fullPath: "/path/to/project/README.md",

name: "README.md",

isFile: true

},

{

fullPath: "/path/to/project/afile.js",

name: "afile.js",

isFile: true

},

subdir

];

var root = {

fullPath: "/path/to/project/",

getContents: function (callback) {

}

};

it("should initialize the treeData", function () {

var model = new ProjectModel.ProjectModel(),

vm = model._viewModel;

var changeFired = false;

model.on(ProjectModel.EVENT_CHANGE, function () {

changeFired = true;

});

waitsForDone(model.setProjectRoot(root));

runs(function () {

expect(vm._treeData.toJS()).toEqual({

"README.md": {},

"afile.js": {},

"subdir": {

children: null

}

});

expect(changeFired).toBe(true);

});

});

});

describe("markers", function () {

var model = new ProjectModel.ProjectModel(),

vm = model._viewModel,

changesFired,

selectionsMade,

creationErrors,

focusEvents,

selectionEvents;

model.projectRoot = {

fullPath: "/foo/"

};

// temporary

vm.projectRoot = model.projectRoot;

model.on(ProjectModel.EVENT_CHANGE, function () {

changesFired++;

});

model.on(ProjectModel.ERROR_CREATION, function (e, error) {

creationErrors.push(error);

});

model.on(ProjectModel.EVENT_SHOULD_FOCUS, function () {

focusEvents++;

});

model.on(ProjectModel.EVENT_SHOULD_SELECT, function (e, data) {

selectionEvents.push(data);

});

beforeEach(function () {

changesFired = 0;

focusEvents = 0;

creationErrors = [];

selectionsMade = [];

selectionEvents = [];

vm._treeData = Immutable.fromJS({

subdir1: {

open: true,

children: {

"afile.js": {}

}

},

"afile.js": {},

subdir2: {

children: null

}

});

vm._selections = Immutable.Map({

selected: null,

context: null,

rename: null

});

model._selections = {};

model._currentFile = null;

model._focused = true;

});

describe("setSelected", function () {

it("should select an unselected file", function () {

model.setSelected("/foo/afile.js");

expect(vm._treeData.getIn(["afile.js", "selected"])).toBe(true);

expect(model._selections.selected).toBe("/foo/afile.js");

expect(changesFired).toBe(1);

expect(selectionEvents).toEqual([{

path: "/foo/afile.js",

previousPath: undefined,

hadFocus: true

}]);

});

it("should change the selection from the old to the new", function () {

model.setSelected("/foo/afile.js");

changesFired = 0;

selectionEvents = [];

model.setSelected("/foo/subdir1/afile.js");

expect(vm._treeData.getIn(["afile.js", "selected"])).toBe(undefined);

expect(vm._treeData.getIn(["subdir1", "children", "afile.js", "selected"])).toBe(true);

expect(changesFired).toBe(1);

expect(selectionEvents).toEqual([{

path: "/foo/subdir1/afile.js",

previousPath: "/foo/afile.js",

hadFocus: true

}]);

});

it("shouldn't fire a changed message if there was no change in selection", function () {

model.setSelected("/foo/afile.js");

expect(changesFired).toBe(1);

changesFired = 0;

model.setSelected("/foo/afile.js");

expect(changesFired).toBe(0);

});

it("should clear the context when there's a new selection", function () {

model.setContext("/foo/afile.js");

model.setSelected("/foo/subdir1/afile.js");

expect(vm._treeData.getIn(["afile.js", "context"])).toBeUndefined();

expect(model._selections.context).toBeUndefined();

});

it("should be able to restore the context to handle the context menu events", function () {

model.setContext("/foo/afile.js");

model.setContext(null, false, true);

model.restoreContext();

expect(model._selections.context).toBe("/foo/afile.js");

});

it("can clear the selection by passing in null", function () {

model.setSelected("/foo/afile.js");

expect(vm._treeData.getIn(["afile.js", "selected"])).toBe(true);

changesFired = 0;

model.setSelected(null);

expect(vm._treeData.getIn(["afile.js", "selected"])).toBeUndefined();

expect(changesFired).toBe(1);

});

it("won't select a file that is not visible", function () {

model.setSelected("/foo/subdir2/bar.js");

expect(changesFired).toBe(0);

expect(model._selections.selected).toBeNull();

});

it("will clear the selected file when selecting one that's not visible", function () {

model.setSelected("/foo/subdir1/afile.js");

model.setSelected("/foo/subdir2/bar.js");

expect(vm._treeData.getIn(["subdir1", "children", "afile.js", "selected"])).toBeUndefined();

expect(model._selections.selected).toBeNull();

});

it("can accept a filesystem object", function () {

model.setSelected({

fullPath: "/foo/afile.js"

});

expect(model._selections.selected).toBe("/foo/afile.js");

});

it("does not select directories", function () {

model.setSelected("/foo/afile.js");

model.setSelected("/foo/subdir1/");

expect(model._selections.selected).toBe("/foo/afile.js");

});

});

describe("setFocused", function () {

it("should clear the selection when the focus leaves the tree", function () {

model.setSelected("/foo/afile.js");

model.setFocused(false);

expect(model._selections.selected).toBe(null);

expect(vm._treeData.getIn(["afile.js", "selected"])).toBeUndefined();

});

});

describe("setDirectoryOpen", function () {

it("will select the current file if it was previously invisible", function () {

model.setSelected("/foo/subdir1/afile.js");

model.setCurrentFile("/foo/subdir1/afile.js");

model.setDirectoryOpen("/foo/subdir1/", false);

expect(model._selections.selected).toBe(null);

model.setDirectoryOpen("/foo/subdir1/", true);

expect(model._selections.selected).toBe("/foo/subdir1/afile.js");

expect(focusEvents).toBe(2);

expect(vm._treeData.getIn(["subdir1", "children", "afile.js", "selected"])).toBe(true);

expect(vm._treeData.getIn(["subdir1", "selected"])).toBeUndefined();

});

it("shouldn't clear the selection when closing the directory if the selected file is still visible", function () {

vm._treeData = vm._treeData.updateIn(["subdir2", "children"], function () {

return Immutable.Map();

});

model.setSelected("/foo/subdir1/afile.js");

model.setCurrentFile("/foo/subdir1/afile.js");

model.setDirectoryOpen("/foo/subdir2/", true);

expect(model._selections.selected).toBe("/foo/subdir1/afile.js");

model.setDirectoryOpen("/foo/subdir2/", false);

expect(model._selections.selected).toBe("/foo/subdir1/afile.js");

});

it("will load the contents of a closed directory when opened", function () {

spyOn(model, "_getDirectoryContents").andReturn(new $.Deferred().resolve([

{

name: "brackets.js",

isFile: true

},

{

name: "src",

isFile: false

}

]).promise());

waitsForDone(model.setDirectoryOpen("/foo/subdir2/", true));

runs(function () {

expect(model._getDirectoryContents).toHaveBeenCalledWith("/foo/subdir2/");

expect(vm._treeData.get("subdir2").toJS()).toEqual({

open: true,

children: {

"brackets.js": {},

"src": {

children: null

}

}

});

});

});

it("shouldn't load a directory that will be closed", function () {

spyOn(model, "_getDirectoryContents").andReturn(new $.Deferred().resolve([]).promise());

waitsForDone(model.setDirectoryOpen("/foo/subdir2", false));

runs(function () {

expect(vm._treeData.get("subdir2").toJS()).toEqual({

children: null

});

});

});

});

describe("setContext", function () {

it("should set the context flag on a file", function () {

model.setContext("/foo/afile.js");

expect(vm._treeData.getIn(["afile.js", "context"])).toBe(true);

expect(changesFired).toBe(1);

});

it("can accept a filesystem object", function () {

model.setContext({

fullPath: "/foo/afile.js"

});

expect(model._selections.context).toBe("/foo/afile.js");

});

it("should change the context from the old to the new", function () {

model.setContext("/foo/afile.js");

changesFired = 0;

model.setContext("/foo/subdir1/afile.js");

expect(vm._treeData.getIn(["afile.js", "context"])).toBe(undefined);

expect(vm._treeData.getIn(["subdir1", "children", "afile.js", "context"])).toBe(true);

expect(changesFired).toBe(1);

});

it("shouldn't fire a changed message if there was no change in context", function () {

model.setContext("/foo/afile.js");

expect(changesFired).toBe(1);

changesFired = 0;

model.setContext("/foo/afile.js");

expect(changesFired).toBe(0);

});

it("can clear the context by passing in null", function () {

model.setContext("/foo/afile.js");

expect(vm._treeData.getIn(["afile.js", "context"])).toBe(true);

changesFired = 0;

model.setContext(null);

expect(vm._treeData.getIn(["afile.js", "context"])).toBeUndefined();

expect(changesFired).toBe(1);

});

});

describe("startRename and friends", function () {

it("should resolve if there's no path or context", function () {

waitsForDone(model.startRename());

});

it("should set the rename flag on a file", function () {

var promise = model.startRename("/foo/afile.js");

expect(vm._treeData.getIn(["afile.js", "rename"])).toBe(true);

expect(vm._treeData.getIn(["afile.js", "context"])).toBe(true);

expect(model._selections).toEqual({

context: "/foo/afile.js",

rename: {

deferred: jasmine.any(Object),

path: "/foo/afile.js",

newPath: "/foo/afile.js",

type: ProjectModel.FILE_RENAMING

}

});

expect(changesFired).toBe(2);

expect(promise.then).toEqual(jasmine.any(Function));

});

it("should expand the parent directory if closed", function () {

model.setDirectoryOpen("/foo/subdir1", false);

expect(vm._treeData.getIn(["subdir1", "open"])).toBeUndefined();

model.startRename("/foo/subdir1/afile.js");

expect(vm._treeData.getIn(["subdir1", "open"])).toBe(true);

});

it("can take a filesystem object or string", function () {

model.startRename({

fullPath: "/foo/afile.js"

});

expect(vm._treeData.getIn(["afile.js", "rename"])).toBe(true);

});

it("can set a rename value", function () {

model.startRename("/foo/afile.js");

model.setRenameValue("/foo/bar.js");