Add support for new version of Jupyter Book (#12086)

* Add support for new jupyter book version * Add changes to the jupyter notebook to create books * Create config file * Add support of new version of jupyter book on ADS * Fix paths for opening folder with v1 and v2 books * Add tests for jupyter book v2 * Update tests * Fix tests * Fix get parent issue * Address PR comments * Fix bookVersion condition in getSections and fix issue on create book notebook * Fix search * update python notebook * Remove commented lines
2026-02-16 10:58:30 -05:00 · 2020-09-10 11:32:58 -07:00
parent ff61eae164
commit 3ff9df8e0b
6 changed files with 959 additions and 582 deletions
--- a/extensions/notebook/src/book/bookModel.ts
+++ b/extensions/notebook/src/book/bookModel.ts
@@ -5,22 +5,30 @@

 import * as vscode from 'vscode';
 import * as yaml from 'js-yaml';
-import { BookTreeItem, BookTreeItemType } from './bookTreeItem';
+import { BookTreeItem, BookTreeItemType, BookTreeItemFormat } from './bookTreeItem';
 import * as constants from '../common/constants';
 import * as path from 'path';
 import * as fileServices from 'fs';
 import * as fs from 'fs-extra';
 import * as loc from '../common/localizedConstants';
-import { IJupyterBookToc, IJupyterBookSection } from '../contracts/content';
-
+import { IJupyterBookToc, JupyterBookSection, IJupyterBookSectionV2, IJupyterBookSectionV1 } from '../contracts/content';

 const fsPromises = fileServices.promises;
+const content = 'content';
+
+export enum BookVersion {
+	v1 = 'v1',
+	v2 = 'v2'
+}

 export class BookModel {
 	private _bookItems: BookTreeItem[];
 	private _allNotebooks = new Map<string, BookTreeItem>();
 	private _tableOfContentsPath: string;
-
+	private _contentFolderPath: string;
+	private _configPath: string;
+	private _bookVersion: BookVersion;
+	private _rootPath: string;
 	private _errorMessage: string;

 	constructor(
@@ -37,11 +45,38 @@ export class BookModel {
 		if (this.isNotebook) {
 			this.readNotebook();
 		} else {
-			await this.loadTableOfContentFiles(this.bookPath);
+			await this.readBookStructure(this.bookPath);
+			await this.loadTableOfContentFiles();
 			await this.readBooks();
 		}
 	}

+	public async readBookStructure(folderPath: string): Promise<void> {
+		// check book structure to determine version
+		let isOlderVersion: boolean;
+		this._configPath = path.posix.join(folderPath, '_config.yml');
+		try {
+			isOlderVersion = (await fs.stat(path.posix.join(folderPath, '_data'))).isDirectory() && (await fs.stat(path.posix.join(folderPath, content))).isDirectory();
+		} catch {
+			isOlderVersion = false;
+		}
+
+		if (isOlderVersion) {
+			let isTocFile = (await fs.stat(path.posix.join(folderPath, '_data', 'toc.yml'))).isFile();
+			if (isTocFile) {
+				this._tableOfContentsPath = path.posix.join(folderPath, '_data', 'toc.yml');
+			}
+			this._bookVersion = BookVersion.v1;
+			this._contentFolderPath = path.posix.join(folderPath, content, '');
+			this._rootPath = path.dirname(path.dirname(this._tableOfContentsPath));
+		} else {
+			this._contentFolderPath = folderPath;
+			this._tableOfContentsPath = path.posix.join(folderPath, '_toc.yml');
+			this._rootPath = path.dirname(this._tableOfContentsPath);
+			this._bookVersion = BookVersion.v2;
+		}
+	}
+
 	public getAllNotebooks(): Map<string, BookTreeItem> {
 		return this._allNotebooks;
 	}
@@ -50,14 +85,12 @@ export class BookModel {
 		return this._allNotebooks.get(this.openAsUntitled ? path.basename(uri) : uri);
 	}

-	public async loadTableOfContentFiles(folderPath: string): Promise<void> {
+	public async loadTableOfContentFiles(): Promise<void> {
 		if (this.isNotebook) {
 			return;
 		}

-		let tableOfContentsPath: string = path.posix.join(folderPath, '_data', 'toc.yml');
-		if (await fs.pathExists(tableOfContentsPath)) {
-			this._tableOfContentsPath = tableOfContentsPath;
+		if (await fs.pathExists(this._tableOfContentsPath)) {
 			vscode.commands.executeCommand('setContext', 'bookOpened', true);
 		} else {
 			this._errorMessage = loc.missingTocError;
@@ -111,16 +144,16 @@ export class BookModel {
 		}

 		if (this._tableOfContentsPath) {
-			let root: string = path.dirname(path.dirname(this._tableOfContentsPath));
 			try {
-				let fileContents = await fsPromises.readFile(path.join(root, '_config.yml'), 'utf-8');
+				let fileContents = await fsPromises.readFile(this._configPath, 'utf-8');
 				const config = yaml.safeLoad(fileContents.toString());
 				fileContents = await fsPromises.readFile(this._tableOfContentsPath, 'utf-8');
-				const tableOfContents: any = yaml.safeLoad(fileContents.toString());
+				let tableOfContents: any = yaml.safeLoad(fileContents.toString());
 				let book: BookTreeItem = new BookTreeItem({
+					version: this._bookVersion,
 					title: config.title,
 					contentPath: this._tableOfContentsPath,
-					root: root,
+					root: this._rootPath,
 					tableOfContents: { sections: this.parseJupyterSections(tableOfContents) },
 					page: tableOfContents,
 					type: BookTreeItemType.Book,
@@ -145,11 +178,11 @@ export class BookModel {
 		return this._bookItems;
 	}

-	public async getSections(tableOfContents: IJupyterBookToc, sections: IJupyterBookSection[], root: string): Promise<BookTreeItem[]> {
+	public async getSections(tableOfContents: IJupyterBookToc, sections: JupyterBookSection[], root: string, book: BookTreeItemFormat): Promise<BookTreeItem[]> {
 		let notebooks: BookTreeItem[] = [];
 		for (let i = 0; i < sections.length; i++) {
-			if (sections[i].url) {
-				if (sections[i].external) {
+			if (sections[i].url || (sections[i] as IJupyterBookSectionV2).file) {
+				if (sections[i].url && ((sections[i] as IJupyterBookSectionV1).external || book.version === BookVersion.v2)) {
 					let externalLink: BookTreeItem = new BookTreeItem({
 						title: sections[i].title,
 						contentPath: undefined,
@@ -158,7 +191,8 @@ export class BookModel {
 						page: sections[i],
 						type: BookTreeItemType.ExternalLink,
 						treeItemCollapsibleState: vscode.TreeItemCollapsibleState.Collapsed,
-						isUntitled: this.openAsUntitled
+						isUntitled: this.openAsUntitled,
+						version: book.version
 					},
 						{
 							light: this._extensionContext.asAbsolutePath('resources/light/link.svg'),
@@ -168,20 +202,29 @@ export class BookModel {

 					notebooks.push(externalLink);
 				} else {
-					let pathToNotebook = path.join(root, 'content', sections[i].url.concat('.ipynb'));
-					let pathToMarkdown = path.join(root, 'content', sections[i].url.concat('.md'));
+					let pathToNotebook: string;
+					let pathToMarkdown: string;
+					if (book.version === BookVersion.v2) {
+						pathToNotebook = path.join(book.root, (sections[i] as IJupyterBookSectionV2).file.concat('.ipynb'));
+						pathToMarkdown = path.join(book.root, (sections[i] as IJupyterBookSectionV2).file.concat('.md'));
+					} else if (sections[i].url) {
+						pathToNotebook = path.join(book.root, content, (sections[i] as IJupyterBookSectionV1).url.concat('.ipynb'));
+						pathToMarkdown = path.join(book.root, content, (sections[i] as IJupyterBookSectionV1).url.concat('.md'));
+					}
+
 					// Note: Currently, if there is an ipynb and a md file with the same name, Jupyter Books only shows the notebook.
 					// Following Jupyter Books behavior for now
 					if (await fs.pathExists(pathToNotebook)) {
 						let notebook = new BookTreeItem({
-							title: sections[i].title,
+							title: sections[i].title ? sections[i].title : (sections[i] as IJupyterBookSectionV2).file,
 							contentPath: pathToNotebook,
 							root: root,
 							tableOfContents: tableOfContents,
 							page: sections[i],
 							type: BookTreeItemType.Notebook,
 							treeItemCollapsibleState: vscode.TreeItemCollapsibleState.Collapsed,
-							isUntitled: this.openAsUntitled
+							isUntitled: this.openAsUntitled,
+							version: book.version
 						},
 							{
 								light: this._extensionContext.asAbsolutePath('resources/light/notebook.svg'),
@@ -204,14 +247,15 @@ export class BookModel {
 						}
 					} else if (await fs.pathExists(pathToMarkdown)) {
 						let markdown: BookTreeItem = new BookTreeItem({
-							title: sections[i].title,
+							title: sections[i].title ? sections[i].title : (sections[i] as IJupyterBookSectionV2).file,
 							contentPath: pathToMarkdown,
 							root: root,
 							tableOfContents: tableOfContents,
 							page: sections[i],
 							type: BookTreeItemType.Markdown,
 							treeItemCollapsibleState: vscode.TreeItemCollapsibleState.Collapsed,
-							isUntitled: this.openAsUntitled
+							isUntitled: this.openAsUntitled,
+							version: book.version
 						},
 							{
 								light: this._extensionContext.asAbsolutePath('resources/light/markdown.svg'),
@@ -235,7 +279,7 @@ export class BookModel {
 	 * Recursively parses out a section of a Jupyter Book.
 	 * @param section The input data to parse
 	 */
-	private parseJupyterSections(section: any[]): IJupyterBookSection[] {
+	private parseJupyterSections(section: any[]): JupyterBookSection[] {
 		try {
 			return section.reduce((acc, val) => Array.isArray(val.sections) ?
 				acc.concat(val).concat(this.parseJupyterSections(val.sections)) : acc.concat(val), []);
@@ -246,15 +290,25 @@ export class BookModel {
 			}
 			throw this._errorMessage;
 		}
-
 	}

 	public get tableOfContentsPath(): string {
 		return this._tableOfContentsPath;
 	}

+	public get contentFolderPath(): string {
+		return this._contentFolderPath;
+	}
+
+	public get configPath(): string {
+		return this._configPath;
+	}
+
 	public get errorMessage(): string {
 		return this._errorMessage;
 	}

+	public get version(): string {
+		return this._bookVersion;
+	}
 }
--- a/extensions/notebook/src/book/bookTreeItem.ts
+++ b/extensions/notebook/src/book/bookTreeItem.ts
@@ -6,9 +6,12 @@
 import * as vscode from 'vscode';
 import * as path from 'path';
 import * as fs from 'fs';
-import { IJupyterBookSection, IJupyterBookToc } from '../contracts/content';
+import { JupyterBookSection, IJupyterBookToc, IJupyterBookSectionV2, IJupyterBookSectionV1 } from '../contracts/content';
 import * as loc from '../common/localizedConstants';
 import { isBookItemPinned } from '../common/utils';
+import { BookVersion } from './bookModel';
+
+const content = 'content';

 export enum BookTreeItemType {
 	Book = 'Book',
@@ -26,13 +29,15 @@ export interface BookTreeItemFormat {
 	type: BookTreeItemType;
 	treeItemCollapsibleState: number;
 	isUntitled: boolean;
+	version?: string;
 }

 export class BookTreeItem extends vscode.TreeItem {
-	private _sections: IJupyterBookSection[];
+	private _sections: JupyterBookSection[];
 	private _uri: string | undefined;
 	private _previousUri: string;
 	private _nextUri: string;
+	public readonly version: string;
 	public command: vscode.Command;

 	constructor(public book: BookTreeItemFormat, icons: any) {
@@ -41,6 +46,7 @@ export class BookTreeItem extends vscode.TreeItem {
 		if (book.type === BookTreeItemType.Book) {
 			this.collapsibleState = book.treeItemCollapsibleState;
 			this._sections = book.page;
+			this.version = book.version;
 			if (book.isUntitled) {
 				this.contextValue = 'providedBook';
 			} else {
@@ -78,7 +84,7 @@ export class BookTreeItem extends vscode.TreeItem {
 				vscode.TreeItemCollapsibleState.Collapsed :
 				vscode.TreeItemCollapsibleState.None;
 		this._sections = this.book.page.sections || this.book.page.subsections;
-		this._uri = this.book.page.url;
+		this._uri = this.book.version === BookVersion.v1 ? this.book.page.url : this.book.page.file;

 		if (this.book.tableOfContents.sections) {
 			let index = (this.book.tableOfContents.sections.indexOf(this.book.page));
@@ -101,14 +107,18 @@ export class BookTreeItem extends vscode.TreeItem {
 	private setPreviousUri(index: number): void {
 		let i = --index;
 		while (i > -1) {
-			if (this.book.tableOfContents.sections[i].url) {
+			let pathToNotebook: string;
+			if (this.book.version === BookVersion.v2 && (this.book.tableOfContents.sections[i] as IJupyterBookSectionV2).file) {
 				// The Notebook editor expects a posix path for the resource (it will still resolve to the correct fsPath based on OS)
-				let pathToNotebook = path.posix.join(this.book.root, 'content', this.book.tableOfContents.sections[i].url.concat('.ipynb'));
-				// eslint-disable-next-line no-sync
-				if (fs.existsSync(pathToNotebook)) {
-					this._previousUri = pathToNotebook;
-					return;
-				}
+				pathToNotebook = path.posix.join(this.book.root, (this.book.tableOfContents.sections[i] as IJupyterBookSectionV2).file.concat('.ipynb'));
+			} else if ((this.book.tableOfContents.sections[i] as IJupyterBookSectionV1).url) {
+				pathToNotebook = path.posix.join(this.book.root, content, (this.book.tableOfContents.sections[i] as IJupyterBookSectionV1).url.concat('.ipynb'));
+			}
+
+			// eslint-disable-next-line no-sync
+			if (fs.existsSync(pathToNotebook)) {
+				this._previousUri = pathToNotebook;
+				return;
 			}
 			i--;
 		}
@@ -117,14 +127,18 @@ export class BookTreeItem extends vscode.TreeItem {
 	private setNextUri(index: number): void {
 		let i = ++index;
 		while (i < this.book.tableOfContents.sections.length) {
-			if (this.book.tableOfContents.sections[i].url) {
+			let pathToNotebook: string;
+			if (this.book.version === BookVersion.v2 && (this.book.tableOfContents.sections[i] as IJupyterBookSectionV2).file) {
 				// The Notebook editor expects a posix path for the resource (it will still resolve to the correct fsPath based on OS)
-				let pathToNotebook = path.posix.join(this.book.root, 'content', this.book.tableOfContents.sections[i].url.concat('.ipynb'));
-				// eslint-disable-next-line no-sync
-				if (fs.existsSync(pathToNotebook)) {
-					this._nextUri = pathToNotebook;
-					return;
-				}
+				pathToNotebook = path.posix.join(this.book.root, (this.book.tableOfContents.sections[i] as IJupyterBookSectionV2).file.concat('.ipynb'));
+			} else if ((this.book.tableOfContents.sections[i] as IJupyterBookSectionV1).url) {
+				pathToNotebook = path.posix.join(this.book.root, content, (this.book.tableOfContents.sections[i] as IJupyterBookSectionV1).url.concat('.ipynb'));
+			}
+
+			// eslint-disable-next-line no-sync
+			if (fs.existsSync(pathToNotebook)) {
+				this._nextUri = pathToNotebook;
+				return;
 			}
 			i++;
 		}
@@ -164,14 +178,14 @@ export class BookTreeItem extends vscode.TreeItem {
 	 * Helper method to find a child section with a specified URL
 	 * @param url The url of the section we're searching for
 	 */
-	public findChildSection(url?: string): IJupyterBookSection | undefined {
+	public findChildSection(url?: string): JupyterBookSection | undefined {
 		if (!url) {
 			return undefined;
 		}
-		return this.findChildSectionRecur(this, url);
+		return this.findChildSectionRecur(this as JupyterBookSection, url);
 	}

-	private findChildSectionRecur(section: IJupyterBookSection, url: string): IJupyterBookSection | undefined {
+	private findChildSectionRecur(section: JupyterBookSection, url: string): JupyterBookSection | undefined {
 		if (section.url && section.url === url) {
 			return section;
 		} else if (section.sections) {
--- a/extensions/notebook/src/book/bookTreeView.ts
+++ b/extensions/notebook/src/book/bookTreeView.ts
@@ -11,16 +11,17 @@ import * as constants from '../common/constants';
 import { IPrompter, IQuestion, confirm } from '../prompts/question';
 import CodeAdapter from '../prompts/adapter';
 import { BookTreeItem, BookTreeItemType } from './bookTreeItem';
-import { BookModel } from './bookModel';
+import { BookModel, BookVersion } from './bookModel';
 import { Deferred } from '../common/promise';
 import { IBookTrustManager, BookTrustManager } from './bookTrustManager';
 import * as loc from '../common/localizedConstants';
 import * as glob from 'fast-glob';
 import { isNullOrUndefined } from 'util';
+import { IJupyterBookSectionV2, IJupyterBookSectionV1 } from '../contracts/content';
 import { debounce, getPinnedNotebooks } from '../common/utils';
 import { IBookPinManager, BookPinManager } from './bookPinManager';

-const Content = 'content';
+const content = 'content';

 interface BookSearchResults {
 	notebookPaths: string[];
@@ -152,7 +153,7 @@ export class BookTreeViewProvider implements vscode.TreeDataProvider<BookTreeIte

 			// add file watcher on toc file.
 			if (!isNotebook) {
-				fs.watchFile(path.join(bookPath, '_data', 'toc.yml'), async (curr, prev) => {
+				fs.watchFile(this.currentBook.tableOfContentsPath, async (curr, prev) => {
 					if (curr.mtime > prev.mtime) {
 						let book = this.books.find(book => book.bookPath === bookPath);
 						if (book) {
@@ -206,7 +207,7 @@ export class BookTreeViewProvider implements vscode.TreeDataProvider<BookTreeIte
 		} finally {
 			// remove watch on toc file.
 			if (deletedBook && !deletedBook.isNotebook) {
-				fs.unwatchFile(path.join(deletedBook.bookPath, '_data', 'toc.yml'));
+				fs.unwatchFile(deletedBook.tableOfContentsPath);
 			}
 		}
 	}
@@ -247,7 +248,7 @@ export class BookTreeViewProvider implements vscode.TreeDataProvider<BookTreeIte
 					const sectionToOpen = bookRoot.findChildSection(urlToOpen);
 					urlPath = sectionToOpen?.url;
 				} else {
-					urlPath = this.currentBook.bookItems[0].tableOfContents.sections[0].url;
+					urlPath = this.currentBook.version === BookVersion.v1 ? (this.currentBook.bookItems[0].tableOfContents.sections[0] as IJupyterBookSectionV1).url : (this.currentBook.bookItems[0].tableOfContents.sections[0] as IJupyterBookSectionV2).file;
 				}
 			}
 			if (urlPath) {
@@ -260,8 +261,8 @@ export class BookTreeViewProvider implements vscode.TreeDataProvider<BookTreeIte
 					}
 				} else {
 					// The Notebook editor expects a posix path for the resource (it will still resolve to the correct fsPath based on OS)
-					const sectionToOpenMarkdown: string = path.posix.join(this.currentBook.bookPath, Content, urlPath.concat('.md'));
-					const sectionToOpenNotebook: string = path.posix.join(this.currentBook.bookPath, Content, urlPath.concat('.ipynb'));
+					const sectionToOpenMarkdown: string = path.posix.join(this.currentBook.contentFolderPath, urlPath.concat('.md'));
+					const sectionToOpenNotebook: string = path.posix.join(this.currentBook.contentFolderPath, urlPath.concat('.ipynb'));
 					if (await fs.pathExists(sectionToOpenMarkdown)) {
 						this.openMarkdown(sectionToOpenMarkdown);
 					}
@@ -411,13 +412,22 @@ export class BookTreeViewProvider implements vscode.TreeDataProvider<BookTreeIte
 	public async searchJupyterBooks(treeItem?: BookTreeItem): Promise<void> {
 		let folderToSearch: string;
 		if (treeItem && treeItem.sections !== undefined) {
-			if (treeItem.uri) {
-				folderToSearch = path.join(treeItem.root, Content, path.dirname(treeItem.uri));
-			} else {
-				folderToSearch = path.join(treeItem.root, Content);
+			if (treeItem.book.version === BookVersion.v1) {
+				if (treeItem.uri) {
+					folderToSearch = path.join(treeItem.book.root, content, path.dirname(treeItem.uri));
+				} else {
+					folderToSearch = path.join(treeItem.root, content);
+				}
+			} else if (treeItem.book.version === BookVersion.v2) {
+				if (treeItem.uri) {
+					folderToSearch = path.join(treeItem.book.root, path.dirname(treeItem.uri));
+				} else {
+					folderToSearch = path.join(treeItem.root);
+				}
 			}
+
 		} else if (this.currentBook && !this.currentBook.isNotebook) {
-			folderToSearch = path.join(this.currentBook.bookPath, Content);
+			folderToSearch = path.join(this.currentBook.contentFolderPath);
 		} else {
 			vscode.window.showErrorMessage(loc.noBooksSelectedError);
 		}
@@ -476,6 +486,9 @@ export class BookTreeViewProvider implements vscode.TreeDataProvider<BookTreeIte
 	}

 	private async getNotebooksInTree(folderPath: string): Promise<BookSearchResults> {
+		let tocTrimLength: number;
+		let ignorePaths: string[] = [];
+
 		let notebookConfig = vscode.workspace.getConfiguration(constants.notebookConfigKey);
 		let maxDepth = notebookConfig[constants.maxBookSearchDepth];
 		// Use default value if user enters an invalid value
@@ -486,13 +499,26 @@ export class BookTreeViewProvider implements vscode.TreeDataProvider<BookTreeIte
 		}

 		let escapedPath = glob.escapePath(folderPath.replace(/\\/g, '/'));
-		let bookFilter = path.posix.join(escapedPath, '**', '_data', 'toc.yml');
-		let bookPaths = await glob(bookFilter, { deep: maxDepth });
-		let tocTrimLength = '/_data/toc.yml'.length * -1;
-		bookPaths = bookPaths.map(path => path.slice(0, tocTrimLength));
+		let bookV1Filter = path.posix.join(escapedPath, '**', '_data', 'toc.yml');
+		let bookV2Filter = path.posix.join(escapedPath, '**', '_toc.yml');
+		let bookPaths = await glob([bookV1Filter, bookV2Filter], { deep: maxDepth });
+		let ignoreNotebook: string[];
+		bookPaths = bookPaths.map(function (path) {
+			if (path.includes('/_data/toc.yml')) {
+				tocTrimLength = '/_data/toc.yml'.length * -1;
+				ignoreNotebook = ['/**/*.ipynb'];
+			} else {
+				tocTrimLength = '/_toc.yml'.length * -1;
+				ignoreNotebook = ['/**/*.ipynb', '/*.ipynb'];
+			}
+			path = path.slice(0, tocTrimLength);
+			ignoreNotebook.map(notebook => ignorePaths.push(glob.escapePath(path) + notebook));
+			return path;
+		});

 		let notebookFilter = path.posix.join(escapedPath, '**', '*.ipynb');
-		let notebookPaths = await glob(notebookFilter, { ignore: bookPaths.map(path => glob.escapePath(path) + '/**/*.ipynb'), deep: maxDepth });
+
+		let notebookPaths = await glob(notebookFilter, { ignore: ignorePaths, deep: maxDepth });

 		return { notebookPaths: notebookPaths, bookPaths: bookPaths };
 	}
@@ -512,7 +538,7 @@ export class BookTreeViewProvider implements vscode.TreeDataProvider<BookTreeIte
 	getChildren(element?: BookTreeItem): Thenable<BookTreeItem[]> {
 		if (element) {
 			if (element.sections) {
-				return Promise.resolve(this.currentBook.getSections(element.tableOfContents, element.sections, element.root).then(sections => { return sections; }));
+				return Promise.resolve(this.currentBook.getSections(element.tableOfContents, element.sections, element.root, element.book).then(sections => { return sections; }));
 			} else {
 				return Promise.resolve([]);
 			}
@@ -528,7 +554,8 @@ export class BookTreeViewProvider implements vscode.TreeDataProvider<BookTreeIte
 	getParent(element?: BookTreeItem): vscode.ProviderResult<BookTreeItem> {
 		if (element?.uri) {
 			let parentPath: string;
-			parentPath = path.join(element.root, Content, element.uri.substring(0, element.uri.lastIndexOf(path.posix.sep)));
+			let contentFolder = element.book.version === BookVersion.v1 ? path.join(element.book.root, content) : element.book.root;
+			parentPath = path.join(contentFolder, element.uri.substring(0, element.uri.lastIndexOf(path.posix.sep)));
 			if (parentPath === element.root) {
 				return undefined;
 			}
--- a/extensions/notebook/src/contracts/content.ts
+++ b/extensions/notebook/src/contracts/content.ts
@@ -64,7 +64,7 @@ export type OutputType =
 	| 'update_display_data';

 export interface IJupyterBookToc {
-	sections: IJupyterBookSection[];
+	sections: JupyterBookSection[];
 }

 /**
@@ -73,7 +73,7 @@ export interface IJupyterBookToc {
 * This is taken from https://github.com/jupyter/jupyter-book/blob/master/jupyter_book/book_template/_data/toc.yml but is not
 * enforced so invalid JSON may result in expected values being undefined.
 */
-export interface IJupyterBookSection {
+export interface IJupyterBookSectionV1 {
 	/**
 	 * Title of chapter or section
 	 */
@@ -85,7 +85,7 @@ export interface IJupyterBookSection {
 	/**
 	 * Contains a list of more entries that make up the chapter's/section's sub-sections
 	 */
-	sections?: IJupyterBookSection[];
+	sections?: IJupyterBookSectionV1[];
 	/**
 	 * If the section shouldn't have a number in the sidebar
 	 */
@@ -114,3 +114,40 @@ export interface IJupyterBookSection {
 	 */
 	header?: boolean;
 }
+
+/**
+ * A section of a Jupyter book.
+ *
+ * This is taken from https://github.com/jupyter/jupyter-book/blob/master/jupyter_book/book_template/_toc.yml but is not
+ * enforced so invalid JSON may result in expected values being undefined.
+ */
+export interface IJupyterBookSectionV2 {
+	/**
+	 * Title of chapter or section
+	 */
+	title?: string;
+	/**
+	 * Path to notebook relative to root folder.
+	 */
+	file?: string;
+	/**
+	 * Contains a list of more entries that make up the chapter's/section's sub-sections
+	 */
+	sections?: IJupyterBookSectionV2[];
+	/**
+	 * If the section shouldn't have a number in the sidebar
+	 */
+	numbered?: boolean;
+	/**
+	 * If you'd like the sections of this chapter to always be expanded in the sidebar.
+	 */
+	expand_sections?: boolean;
+	/**
+	 * External link
+	 */
+	url?: string;
+}
+
+// type that supports new and old version
+export type JupyterBookSection = IJupyterBookSectionV1 | IJupyterBookSectionV2;
+
--- a/extensions/notebook/src/test/book/book.test.ts
+++ b/extensions/notebook/src/test/book/book.test.ts
@@ -47,7 +47,6 @@ export function equalBookItems(book: BookTreeItem, expectedBook: IExpectedBookIt

 describe('BooksTreeViewTests', function () {
 	describe('BookTreeViewProvider', () => {
-
 		let mockExtensionContext: vscode.ExtensionContext;
 		let appContext: AppContext;
 		let nonBookFolderPath: string;
@@ -418,405 +417,552 @@ describe('BooksTreeViewTests', function () {

 	});

-	describe('BookTreeViewProvider.getTableOfContentFiles', function (): void {
-		let rootFolderPath: string;
-		let tableOfContentsFile: string;
+	describe('BookTreeViewProvider.getTableOfContentFiles', function() {
+		let rootFolderPath = path.join(os.tmpdir(), `BookTestData_${uuid.v4()}`);
 		let bookTreeViewProvider: BookTreeViewProvider;
-		let folder: vscode.WorkspaceFolder;
-
-		this.beforeAll(async () => {
-			rootFolderPath = path.join(os.tmpdir(), `BookTestData_${uuid.v4()}`);
-			let dataFolderPath: string = path.join(rootFolderPath, '_data');
-			tableOfContentsFile = path.join(dataFolderPath, 'toc.yml');
-			let tableOfContentsFileIgnore: string = path.join(rootFolderPath, 'toc.yml');
-			await fs.mkdir(rootFolderPath);
-			await fs.mkdir(dataFolderPath);
-			await fs.writeFile(tableOfContentsFile, '- title: Notebook1\n  url: /notebook1\n  sections:\n  - title: Notebook2\n    url: /notebook2\n  - title: Notebook3\n    url: /notebook3\n- title: Markdown\n  url: /markdown\n- title: GitHub\n  url: https://github.com/\n  external: true');
-			await fs.writeFile(tableOfContentsFileIgnore, '');
-			const mockExtensionContext = new MockExtensionContext();
-			folder = {
-				uri: vscode.Uri.file(rootFolderPath),
-				name: '',
-				index: 0
-			};
-			bookTreeViewProvider = new BookTreeViewProvider([folder], mockExtensionContext, false, 'bookTreeView', NavigationProviders.NotebooksNavigator);
-			let errorCase = new Promise((resolve, reject) => setTimeout(() => resolve(), 5000));
-			await Promise.race([bookTreeViewProvider.initialized, errorCase.then(() => { throw new Error('BookTreeViewProvider did not initialize in time'); })]);
-		});
-
-		it('should ignore toc.yml files not in _data folder', async () => {
-			await bookTreeViewProvider.currentBook.loadTableOfContentFiles(rootFolderPath);
-			let path = bookTreeViewProvider.currentBook.tableOfContentsPath;
-			should(vscode.Uri.file(path).fsPath).equal(vscode.Uri.file(tableOfContentsFile).fsPath);
-		});
-
-		this.afterAll(async function (): Promise<void> {
-			if (await exists(rootFolderPath)) {
-				await promisify(rimraf)(rootFolderPath);
+		let runs = [
+			{
+				it: 'v1',
+				folderPaths : {
+					'dataFolderPath' : path.join(rootFolderPath, '_data'),
+					'contentFolderPath' : path.join(rootFolderPath, 'content'),
+					'configFile' : path.join(rootFolderPath, '_config.yml'),
+					'tableOfContentsFile' : path.join(rootFolderPath,'_data', 'toc.yml'),
+					'notebook2File' : path.join(rootFolderPath, 'content', 'notebook2.ipynb'),
+					'tableOfContentsFileIgnore' : path.join(rootFolderPath, 'toc.yml')
+				},
+				contents : {
+					'config' :  'title: Test Book',
+					'toc' : '- title: Notebook1\n  url: /notebook1\n  sections:\n  - title: Notebook2\n    url: /notebook2\n  - title: Notebook3\n    url: /notebook3\n- title: Markdown\n  url: /markdown\n- title: GitHub\n  url: https://github.com/\n  external: true'
+				}
+			},
+			{
+				it: 'v2',
+				folderPaths : {
+					'dataFolderPath' : path.join(rootFolderPath, '_data'),
+					'configFile' : path.join(rootFolderPath, '_config.yml'),
+					'tableOfContentsFile' : path.join(rootFolderPath, '_toc.yml'),
+					'notebook2File' : path.join(rootFolderPath,'notebook2.ipynb'),
+					'tableOfContentsFileIgnore' : path.join(rootFolderPath, '_data', 'toc.yml')
+				},
+				contents : {
+					'config' :  'title: Test Book',
+					'toc' : '- title: Notebook1\n  file: /notebook1\n  sections:\n  - title: Notebook2\n    file: /notebook2\n  - title: Notebook3\n    file: /notebook3\n- title: Markdown\n  file: /markdown\n- title: GitHub\n  url: https://github.com/\n'
+				}
 			}
+		];
+		runs.forEach(function (run){
+			describe('BookTreeViewProvider.getTableOfContentFiles on ' + run.it, function (): void {
+				let folder: vscode.WorkspaceFolder;
+
+				before(async () => {
+					await fs.mkdir(rootFolderPath);
+					await fs.mkdir(run.folderPaths.dataFolderPath);
+					if(run.it === 'v1') {
+						await fs.mkdir(run.folderPaths.contentFolderPath);
+					}
+					await fs.writeFile(run.folderPaths.tableOfContentsFile, run.contents.toc);
+					await fs.writeFile(run.folderPaths.tableOfContentsFileIgnore, '');
+					await fs.writeFile(run.folderPaths.notebook2File, '');
+
+					const mockExtensionContext = new MockExtensionContext();
+					folder = {
+						uri: vscode.Uri.file(rootFolderPath),
+						name: '',
+						index: 0
+					};
+					bookTreeViewProvider = new BookTreeViewProvider([folder], mockExtensionContext, false, 'bookTreeView', NavigationProviders.NotebooksNavigator);
+					let errorCase = new Promise((resolve, reject) => setTimeout(() => resolve(), 5000));
+					await Promise.race([bookTreeViewProvider.initialized, errorCase.then(() => { throw new Error('BookTreeViewProvider did not initialize in time'); })]);
+				});
+
+				if(run.it === 'v1') {
+					it('should ignore toc.yml files not in _data folder', async () => {
+						await bookTreeViewProvider.currentBook.readBookStructure(rootFolderPath);
+						await bookTreeViewProvider.currentBook.loadTableOfContentFiles();
+						let path = bookTreeViewProvider.currentBook.tableOfContentsPath;
+						should(vscode.Uri.file(path).fsPath).equal(vscode.Uri.file(run.folderPaths.tableOfContentsFile).fsPath);
+					});
+				} else if (run.it === 'v2'){
+					it('should ignore toc.yml files not under the root book folder', async () => {
+						await bookTreeViewProvider.currentBook.readBookStructure(rootFolderPath);
+						await bookTreeViewProvider.currentBook.loadTableOfContentFiles();
+						let path = bookTreeViewProvider.currentBook.tableOfContentsPath;
+						should(vscode.Uri.file(path).fsPath).equal(vscode.Uri.file(run.folderPaths.tableOfContentsFile).fsPath);
+					});
+				}
+
+				after(async function (): Promise<void> {
+					if (await exists(rootFolderPath)) {
+						await promisify(rimraf)(rootFolderPath);
+					}
+				});
+			});
 		});
 	});

-
-	describe('BookTreeViewProvider.getBooks', function (): void {
-		let rootFolderPath: string;
-		let configFile: string;
-		let folder: vscode.WorkspaceFolder;
+	describe('BookTreeViewProvider.getBooks', function() {
+		let rootFolderPath = path.join(os.tmpdir(), `BookTestData_${uuid.v4()}`);
 		let bookTreeViewProvider: BookTreeViewProvider;
-		let tocFile: string;
-
-		this.beforeAll(async () => {
-			rootFolderPath = path.join(os.tmpdir(), `BookTestData_${uuid.v4()}`);
-			let dataFolderPath: string = path.join(rootFolderPath, '_data');
-			configFile = path.join(rootFolderPath, '_config.yml');
-			tocFile = path.join(dataFolderPath, 'toc.yml');
-			await fs.mkdir(rootFolderPath);
-			await fs.mkdir(dataFolderPath);
-			await fs.writeFile(tocFile, 'title: Test');
-			const mockExtensionContext = new MockExtensionContext();
-			folder = {
-				uri: vscode.Uri.file(rootFolderPath),
-				name: '',
-				index: 0
-			};
-			bookTreeViewProvider = new BookTreeViewProvider([folder], mockExtensionContext, false, 'bookTreeView', NavigationProviders.NotebooksNavigator);
-			let errorCase = new Promise((resolve, reject) => setTimeout(() => resolve(), 5000));
-			await Promise.race([bookTreeViewProvider.initialized, errorCase.then(() => { throw new Error('BookTreeViewProvider did not initialize in time'); })]);
-		});
-
-		it('should show error message if config.yml file not found', async () => {
-			await bookTreeViewProvider.currentBook.readBooks();
-			should(bookTreeViewProvider.currentBook.errorMessage).equal(readBookError(bookTreeViewProvider.currentBook.bookPath, `ENOENT: no such file or directory, open '${configFile}'`));
-		});
-
-		it('should show error if toc.yml file format is invalid', async function (): Promise<void> {
-			await fs.writeFile(configFile, 'title: Test Book');
-			await bookTreeViewProvider.currentBook.readBooks();
-			should(bookTreeViewProvider.currentBook.errorMessage).equal(readBookError(bookTreeViewProvider.currentBook.bookPath, `Invalid toc file`));
-		});
-
-		this.afterAll(async function (): Promise<void> {
-			if (await exists(rootFolderPath)) {
-				await promisify(rimraf)(rootFolderPath);
+		let runs = [
+			{
+				it: 'v1',
+				folderPaths : {
+					'dataFolderPath' : path.join(rootFolderPath, '_data'),
+					'contentFolderPath' : path.join(rootFolderPath, 'content'),
+					'configFile' : path.join(rootFolderPath, '_config.yml'),
+					'tableofContentsFile' : path.join(rootFolderPath,'_data', 'toc.yml'),
+					'notebook2File' : path.join(rootFolderPath, 'content', 'notebook2.ipynb'),
+				},
+				contents : {
+					'config' :  'title: Test Book',
+					'toc' : '- title: Notebook1\n  url: /notebook1\n- title: Notebook2\n  url: /notebook2'
+				}
+			}, {
+				it: 'v2',
+				folderPaths : {
+					'configFile' : path.join(rootFolderPath, '_config.yml'),
+					'tableofContentsFile' : path.join(rootFolderPath, '_toc.yml'),
+					'notebook2File' : path.join(rootFolderPath, 'notebook2.ipynb'),
+				},
+				contents : {
+					'config' :  'title: Test Book',
+					'toc' : '- title: Notebook1\n  file: /notebook1\n- title: Notebook2\n  file: /notebook2'
+				}
 			}
+		];
+		runs.forEach(function (run){
+			describe('BookTreeViewProvider.getBooks on ' + run.it, function (): void {
+				let folder: vscode.WorkspaceFolder;
+				before(async () => {
+					await fs.mkdir(rootFolderPath);
+					if(run.it === 'v1'){
+						await fs.mkdir(run.folderPaths.dataFolderPath);
+						await fs.mkdir(run.folderPaths.contentFolderPath);
+					}
+					await fs.writeFile(run.folderPaths.tableofContentsFile, run.contents.config);
+					const mockExtensionContext = new MockExtensionContext();
+					folder = {
+						uri: vscode.Uri.file(rootFolderPath),
+						name: '',
+						index: 0
+					};
+					bookTreeViewProvider = new BookTreeViewProvider([folder], mockExtensionContext, false, 'bookTreeView', NavigationProviders.NotebooksNavigator);
+					let errorCase = new Promise((resolve, reject) => setTimeout(() => resolve(), 5000));
+					await Promise.race([bookTreeViewProvider.initialized, errorCase.then(() => { throw new Error('BookTreeViewProvider did not initialize in time'); })]);
+				});
+
+				it('should show error message if config.yml file not found', async () => {
+					await bookTreeViewProvider.currentBook.readBooks();
+					should(bookTreeViewProvider.currentBook.errorMessage).equal(readBookError(bookTreeViewProvider.currentBook.bookPath, `ENOENT: no such file or directory, open '${run.folderPaths.configFile}'`));
+				});
+
+				it('should show error if toc.yml file format is invalid', async function (): Promise<void> {
+					await fs.writeFile(run.folderPaths.configFile, run.contents.config);
+					await bookTreeViewProvider.currentBook.readBooks();
+					should(bookTreeViewProvider.currentBook.errorMessage).equal(readBookError(bookTreeViewProvider.currentBook.bookPath, `Invalid toc file`));
+				});
+
+				after(async function (): Promise<void> {
+					if (await exists(rootFolderPath)) {
+						await promisify(rimraf)(rootFolderPath);
+					}
+				});
+		});
+	})});
+
+	describe('BookTreeViewProvider.getSections', function() {
+		let rootFolderPath = path.join(os.tmpdir(), `BookTestData_${uuid.v4()}`);
+		let bookTreeViewProvider: BookTreeViewProvider;
+		let runs = [
+			{
+				it: 'v1',
+				folderPaths : {
+					'dataFolderPath' : path.join(rootFolderPath, '_data'),
+					'contentFolderPath' : path.join(rootFolderPath, 'content'),
+					'configFile' : path.join(rootFolderPath, '_config.yml'),
+					'tableofContentsFile' : path.join(rootFolderPath,'_data', 'toc.yml'),
+					'notebook2File' : path.join(rootFolderPath, 'content', 'notebook2.ipynb'),
+				},
+				contents : {
+					'config' :  'title: Test Book',
+					'toc' : '- title: Notebook1\n  url: /notebook1\n- title: Notebook2\n  url: /notebook2'
+				}
+			},{
+				it: 'v2',
+				folderPaths : {
+					'configFile' : path.join(rootFolderPath, '_config.yml'),
+					'tableofContentsFile' : path.join(rootFolderPath,'_toc.yml'),
+					'notebook2File' : path.join(rootFolderPath,'notebook2.ipynb'),
+				},
+				contents : {
+					'config' :  'title: Test Book',
+					'toc' : '- title: Notebook1\n  file: /notebook1\n- title: Notebook2\n  file: /notebook2'
+				}
+			}
+		];
+		runs.forEach(function (run){
+			describe('BookTreeViewProvider.getSections on ' + run.it, function (): void {
+			let folder: vscode.WorkspaceFolder[];
+			let expectedNotebook2: IExpectedBookItem;
+
+			before(async () => {
+				expectedNotebook2 = {
+					title: 'Notebook2',
+					url: '/notebook2',
+					previousUri: undefined,
+					nextUri: undefined
+				};
+				await fs.mkdir(rootFolderPath);
+				if(run.it === 'v1'){
+					await fs.mkdir(run.folderPaths.dataFolderPath);
+					await fs.mkdir(run.folderPaths.contentFolderPath);
+				}
+				await fs.writeFile(run.folderPaths.configFile, run.contents.config);
+				await fs.writeFile(run.folderPaths.tableofContentsFile, run.contents.toc);
+				await fs.writeFile(run.folderPaths.notebook2File, '');
+
+				const mockExtensionContext = new MockExtensionContext();
+				folder = [{
+					uri: vscode.Uri.file(rootFolderPath),
+					name: '',
+					index: 0
+				}];
+				bookTreeViewProvider = new BookTreeViewProvider(folder, mockExtensionContext, false, 'bookTreeView', NavigationProviders.NotebooksNavigator);
+				let errorCase = new Promise((resolve, reject) => setTimeout(() => resolve(), 5000));
+				await Promise.race([bookTreeViewProvider.initialized, errorCase.then(() => { throw new Error('BookTreeViewProvider did not initialize in time'); })]);
+			});
+
+			it('should show error if notebook or markdown file is missing', async function (): Promise<void> {
+				let books: BookTreeItem[] = bookTreeViewProvider.currentBook.bookItems;
+				let children = await bookTreeViewProvider.currentBook.getSections({ sections: [] }, books[0].sections, rootFolderPath, books[0].book);
+				should(bookTreeViewProvider.currentBook.errorMessage).equal('Missing file : Notebook1');
+				// rest of book should be detected correctly even with a missing file
+				equalBookItems(children[0], expectedNotebook2);
+			});
+
+			after(async function (): Promise<void> {
+				if (await exists(rootFolderPath)) await promisify(rimraf)(rootFolderPath);
+			});
+		});
+	})});
+
+	describe('BookTreeViewProvider.Commands', function() {
+		let rootFolderPath = path.join(os.tmpdir(), `BookTestData_${uuid.v4()}`);
+		let bookTreeViewProvider: BookTreeViewProvider;
+		let runs = [
+			{
+				it: 'v1',
+				folderPaths : {
+					'dataFolderPath' : path.join(rootFolderPath, '_data'),
+					'contentFolderPath' : path.join(rootFolderPath, 'content'),
+					'configFile' : path.join(rootFolderPath, '_config.yml'),
+					'tableofContentsFile' : path.join(rootFolderPath,'_data', 'toc.yml'),
+					'notebook1File' : path.join(rootFolderPath, 'content', 'notebook1.ipynb'),
+					'notebook2File' : path.join(rootFolderPath, 'content', 'notebook2.ipynb'),
+					'markdownFile' : path.join(rootFolderPath, 'content', 'readme.md')
+				},
+				contents : {
+					'config' :  'title: Test Book',
+					'toc' : '- title: Home\n  url: /readme\n- title: Notebook1\n  url: /notebook1\n- title: Notebook2\n  url: /notebook2'
+				}
+			},
+			{
+				it: 'v2',
+				folderPaths : {
+					'configFile' : path.join(rootFolderPath, '_config.yml'),
+					'tableofContentsFile' : path.join(rootFolderPath, '_toc.yml'),
+					'notebook1File' : path.join(rootFolderPath, 'notebook1.ipynb'),
+					'notebook2File' : path.join(rootFolderPath, 'notebook2.ipynb'),
+					'markdownFile' : path.join(rootFolderPath, 'readme.md')
+				},
+				contents : {
+					'config' :  'title: Test Book',
+					'toc' : '- title: Home\n  file: /readme\n- title: Notebook1\n  file: /notebook1\n- title: Notebook2\n  file: /notebook2'
+				}
+			}
+		];
+		runs.forEach(function (run){
+			describe('BookTreeViewProvider.Commands on ' + run.it, function (): void {
+				before(async () => {
+					await fs.mkdir(rootFolderPath);
+					if(run.it === 'v1'){
+						await fs.mkdir(run.folderPaths.dataFolderPath);
+						await fs.mkdir(run.folderPaths.contentFolderPath);
+					}
+					await fs.writeFile(run.folderPaths.configFile, run.contents.config);
+					await fs.writeFile(run.folderPaths.tableofContentsFile, run.contents.toc);
+					await fs.writeFile(run.folderPaths.notebook1File, '');
+					await fs.writeFile(run.folderPaths.notebook2File, '');
+					await fs.writeFile(run.folderPaths.markdownFile, '');
+
+					const mockExtensionContext = new MockExtensionContext();
+					bookTreeViewProvider = new BookTreeViewProvider([], mockExtensionContext, false, 'bookTreeView', NavigationProviders.NotebooksNavigator);
+					let errorCase = new Promise((resolve, reject) => setTimeout(() => resolve(), 5000));
+					await Promise.race([bookTreeViewProvider.initialized, errorCase.then(() => { throw new Error('BookTreeViewProvider did not initialize in time'); })]);
+				});
+
+				afterEach(async function (): Promise<void> {
+					sinon.restore();
+					await vscode.commands.executeCommand('workbench.action.closeAllEditors');
+				});
+
+				it('should add book and initialize book on openBook', async () => {
+					should(bookTreeViewProvider.books.length).equal(0, 'Invalid books on initialize.');
+
+					let showPreviewSpy = sinon.spy(bookTreeViewProvider, 'showPreviewFile');
+
+					await bookTreeViewProvider.openBook(rootFolderPath);
+					should(bookTreeViewProvider.books.length).equal(1, 'Failed to initialize the book on open');
+					should(showPreviewSpy.notCalled).be.true('Should not call showPreviewFile when showPreview isn\' true');
+				});
+
+				it('openMarkdown should open markdown in the editor', async () => {
+					let executeCommandSpy = sinon.spy(vscode.commands, 'executeCommand');
+					let notebookPath = run.folderPaths.markdownFile;
+					bookTreeViewProvider.openMarkdown(notebookPath);
+					should(executeCommandSpy.calledWith('markdown.showPreview')).be.true('openMarkdown should have called markdown.showPreview');
+				});
+
+				// TODO: Need to investigate why it's failing on linux.
+				it.skip('openNotebook should open notebook in the editor', async () => {
+					let showNotebookSpy = sinon.spy(azdata.nb, 'showNotebookDocument');
+					let notebookPath = run.folderPaths.notebook2File;
+					await bookTreeViewProvider.openNotebook(notebookPath);
+					should(showNotebookSpy.calledWith(vscode.Uri.file(notebookPath))).be.true(`Should have opened the notebook from ${notebookPath} in the editor.`);
+				});
+
+				it('openNotebookAsUntitled should open a notebook as untitled file in the editor', async () => {
+					let notebookPath = run.folderPaths.notebook2File;
+					await bookTreeViewProvider.openNotebookAsUntitled(notebookPath);
+					should(azdata.nb.notebookDocuments.find(doc => doc.uri.scheme === 'untitled')).not.be.undefined();
+				});
+
+				it('openExternalLink should open link', async () => {
+					let executeCommandSpy = sinon.spy(vscode.commands, 'executeCommand');
+					let notebookPath = run.folderPaths.markdownFile;
+					bookTreeViewProvider.openMarkdown(notebookPath);
+					should(executeCommandSpy.calledWith('markdown.showPreview')).be.true('openMarkdown should have called markdown.showPreview');
+				});
+
+				it('should call showPreviewFile on openBook when showPreview flag is set', async () => {
+					await bookTreeViewProvider.closeBook(bookTreeViewProvider.books[0].bookItems[0]);
+					let showPreviewSpy = sinon.spy(bookTreeViewProvider, 'showPreviewFile');
+
+					await bookTreeViewProvider.openBook(rootFolderPath, undefined, true);
+					should(bookTreeViewProvider.books.length).equal(1, 'Failed to initialize the book on open');
+					should(showPreviewSpy.calledOnce).be.true('Should have called showPreviewFile.');
+				});
+
+				it('should add book when bookPath contains special characters on openBook', async () => {
+					let rootFolderPath2 = path.join(os.tmpdir(), `BookTestData(1)_${uuid.v4()}`);
+					let dataFolderPath2 = path.join(rootFolderPath2, '_data');
+					let contentFolderPath2 = path.join(rootFolderPath2, 'content');
+					let configFile2 = path.join(rootFolderPath2, '_config.yml');
+					let tableOfContentsFile2 = path.join(dataFolderPath2, 'toc.yml');
+					let notebook2File2 = path.join(contentFolderPath2, 'notebook2.ipynb');
+					await fs.mkdir(rootFolderPath2);
+					await fs.mkdir(dataFolderPath2);
+					await fs.mkdir(contentFolderPath2);
+					await fs.writeFile(configFile2, 'title: Test Book');
+					await fs.writeFile(tableOfContentsFile2, '- title: Notebook1\n  url: /notebook1\n- title: Notebook2\n  url: /notebook2');
+					await fs.writeFile(notebook2File2, '');
+
+					await bookTreeViewProvider.openBook(rootFolderPath2);
+					should(bookTreeViewProvider.books.length).equal(2, 'Failed to initialize the book on open');
+
+					await promisify(rimraf)(rootFolderPath2);
+				});
+
+				it('should get notebook path with untitled schema on openNotebookAsUntitled', async () => {
+					let notebookUri = bookTreeViewProvider.getUntitledNotebookUri(run.folderPaths.notebook2File);
+					should(notebookUri.scheme).equal('untitled', 'Failed to get untitled uri of the resource');
+				});
+
+				it('openNotebookFolder without folderPath should prompt for folder path and invoke loadNotebooksInFolder', async () => {
+					sinon.stub(vscode.window, 'showOpenDialog').returns(Promise.resolve([vscode.Uri.file(rootFolderPath)]));
+					let loadNotebooksSpy = sinon.spy(bookTreeViewProvider, 'loadNotebooksInFolder');
+					await bookTreeViewProvider.openNotebookFolder();
+
+					should(loadNotebooksSpy.calledWith(rootFolderPath)).be.true('openNotebookFolder should have called loadNotebooksInFolder passing the folderPath');
+				});
+
+				it('openNotebookFolder with folderPath shouldn\'t prompt for folder path but invoke loadNotebooksInFolder with the provided folderPath', async () => {
+					let showOpenDialogSpy = sinon.spy(vscode.window, 'showOpenDialog');
+					let loadNotebooksSpy = sinon.spy(bookTreeViewProvider, 'loadNotebooksInFolder');
+					await bookTreeViewProvider.openNotebookFolder(rootFolderPath);
+
+					should(showOpenDialogSpy.notCalled).be.true('openNotebookFolder with folderPath shouldn\'t prompt to select folder');
+					should(loadNotebooksSpy.calledOnce).be.true('openNotebookFolder should have called loadNotebooksInFolder');
+				});
+
+				it('openNewBook should prompt for notebook path and invoke openBook', async () => {
+					sinon.stub(vscode.window, 'showOpenDialog').returns(Promise.resolve([vscode.Uri.file(rootFolderPath)]));
+					let openBookSpy = sinon.spy(bookTreeViewProvider, 'openBook');
+					await bookTreeViewProvider.openNewBook();
+
+					should(openBookSpy.calledOnce).be.true('openNewBook should have called openBook');
+				});
+
+				it('searchJupyterBooks should call command that opens Search view', async () => {
+					let executeCommandSpy = sinon.spy(vscode.commands, 'executeCommand');
+					await bookTreeViewProvider.searchJupyterBooks(bookTreeViewProvider.books[0].bookItems[0]);
+					should(executeCommandSpy.calledWith('workbench.action.findInFiles')).be.true('searchJupyterBooks should have called command to open Search view');
+				});
+
+				it('saveJupyterBooks should prompt location and openBook', async () => {
+					let saveFolderPath = path.join(os.tmpdir(), `Book_${uuid.v4()}`);
+					await fs.mkdir(saveFolderPath);
+					sinon.stub(vscode.window, 'showOpenDialog').returns(Promise.resolve([vscode.Uri.file(saveFolderPath)]));
+					let executeCommandSpy = sinon.spy(vscode.commands, 'executeCommand');
+					await bookTreeViewProvider.saveJupyterBooks();
+					should(executeCommandSpy.calledWith('bookTreeView.openBook')).be.true('saveJupyterBooks should have called command openBook after saving');
+
+					await promisify(rimraf)(saveFolderPath);
+				});
+
+				it('should remove book on closeBook', async () => {
+					let length: number = bookTreeViewProvider.books.length;
+					await bookTreeViewProvider.closeBook(bookTreeViewProvider.books[0].bookItems[0]);
+					should(bookTreeViewProvider.books.length).equal(length - 1, 'Failed to remove the book on close');
+				});
+
+				after(async function (): Promise<void> {
+					if (await exists(rootFolderPath)) {
+						await promisify(rimraf)(rootFolderPath);
+					}
+				});
+			});
 		});
 	});

-
-	describe('BookTreeViewProvider.getSections', function (): void {
-		let rootFolderPath: string;
-		let tableOfContentsFile: string;
+	describe('BookTreeViewProvider.openNotebookFolder', function() {
+		let rootFolderPath = path.join(os.tmpdir(), `BookFolderTest_${uuid.v4()}`);
 		let bookTreeViewProvider: BookTreeViewProvider;
-		let folder: vscode.WorkspaceFolder;
-		let expectedNotebook2: IExpectedBookItem;
+		let runs = [
+			{
+				it: 'v1',
+				folderPaths : {
+					'bookFolderPath' : path.join(rootFolderPath, 'BookTestData'),
+					'dataFolderPath' : path.join(rootFolderPath, 'BookTestData', '_data'),
+					'contentFolderPath' : path.join(rootFolderPath, 'BookTestData', 'content'),
+					'configFile' : path.join(rootFolderPath, 'BookTestData', '_config.yml'),
+					'tableOfContentsFile' : path.join(rootFolderPath,'BookTestData','_data', 'toc.yml'),
+					'bookNotebookFile' : path.join(rootFolderPath, 'BookTestData', 'content', 'notebook1.ipynb'),
+					'notebookFolderPath' : path.join(rootFolderPath, 'NotebookTestData'),
+					'standaloneNotebookFile' : path.join(rootFolderPath, 'NotebookTestData','notebook2.ipynb')
+				},
+				contents : {
+					'config' :  'title: Test Book',
+					'toc' : '- title: Notebook1\n  url: /notebook1',
+					'bookTitle' : 'Test Book',
+					'standaloneNotebookTitle' : 'notebook2'
+				}
+			},
+			{
+				it: 'v2',
+				folderPaths : {
+					'bookFolderPath' : path.join(rootFolderPath, 'BookTestData'),
+					'configFile' : path.join(rootFolderPath, 'BookTestData', '_config.yml'),
+					'tableOfContentsFile' : path.join(rootFolderPath,'BookTestData', '_toc.yml'),
+					'bookNotebookFile' : path.join(rootFolderPath, 'BookTestData','notebook1.ipynb'),
+					'notebookFolderPath' : path.join(rootFolderPath, 'NotebookTestData'),
+					'standaloneNotebookFile' : path.join(rootFolderPath, 'NotebookTestData','notebook2.ipynb')
+				},
+				contents : {
+					'config' :  'title: Test Book',
+					'toc' : '- title: Notebook1\n  file: /notebook1',
+					'bookTitle' : 'Test Book',
+					'standaloneNotebookTitle' : 'notebook2'
+				}
+		}];
+		runs.forEach(function (run){
+			describe('BookTreeViewProvider.openNotebookFolder on ' + run.it, function (): void {
+				before(async () => {

-		this.beforeAll(async () => {
-			rootFolderPath = path.join(os.tmpdir(), `BookTestData_${uuid.v4()}`);
-			let dataFolderPath = path.join(rootFolderPath, '_data');
-			let contentFolderPath = path.join(rootFolderPath, 'content');
-			let configFile = path.join(rootFolderPath, '_config.yml');
-			tableOfContentsFile = path.join(dataFolderPath, 'toc.yml');
-			let notebook2File = path.join(contentFolderPath, 'notebook2.ipynb');
-			expectedNotebook2 = {
-				title: 'Notebook2',
-				url: '/notebook2',
-				previousUri: undefined,
-				nextUri: undefined
-			};
-			await fs.mkdir(rootFolderPath);
-			await fs.mkdir(dataFolderPath);
-			await fs.mkdir(contentFolderPath);
-			await fs.writeFile(configFile, 'title: Test Book');
-			await fs.writeFile(tableOfContentsFile, '- title: Notebook1\n  url: /notebook1\n- title: Notebook2\n  url: /notebook2');
-			await fs.writeFile(notebook2File, '');
+					await fs.mkdir(rootFolderPath);
+					await fs.mkdir(run.folderPaths.bookFolderPath);
+					if(run.it === 'v1') {
+						await fs.mkdir(run.folderPaths.dataFolderPath);
+						await fs.mkdir(run.folderPaths.contentFolderPath);
+					}
+					await fs.mkdir(run.folderPaths.notebookFolderPath);
+					await fs.writeFile(run.folderPaths.configFile, run.contents.config);
+					await fs.writeFile(run.folderPaths.tableOfContentsFile, run.contents.toc);
+					await fs.writeFile(run.folderPaths.bookNotebookFile, '');
+					await fs.writeFile(run.folderPaths.standaloneNotebookFile, '');

-			const mockExtensionContext = new MockExtensionContext();
-			folder = {
-				uri: vscode.Uri.file(rootFolderPath),
-				name: '',
-				index: 0
-			};
-			bookTreeViewProvider = new BookTreeViewProvider([folder], mockExtensionContext, false, 'bookTreeView', NavigationProviders.NotebooksNavigator);
-			let errorCase = new Promise((resolve, reject) => setTimeout(() => resolve(), 5000));
-			await Promise.race([bookTreeViewProvider.initialized, errorCase.then(() => { throw new Error('BookTreeViewProvider did not initialize in time'); })]);
+					const mockExtensionContext = new MockExtensionContext();
+					bookTreeViewProvider = new BookTreeViewProvider([], mockExtensionContext, false, 'bookTreeView', NavigationProviders.NotebooksNavigator);
+					let errorCase = new Promise((resolve, reject) => setTimeout(() => resolve(), 5000));
+					await Promise.race([bookTreeViewProvider.initialized, errorCase.then(() => { throw new Error('BookTreeViewProvider did not initialize in time'); })]);
+				});
+
+				it('should include books and notebooks when opening parent folder', async () => {
+					await bookTreeViewProvider.loadNotebooksInFolder(rootFolderPath);
+					should(bookTreeViewProvider.books.length).equal(2, 'Should have loaded a book and a notebook');
+
+					validateIsBook(bookTreeViewProvider.books[0]);
+					validateIsNotebook(bookTreeViewProvider.books[1]);
+				});
+
+				it('should include only books when opening books folder', async () => {
+					await bookTreeViewProvider.loadNotebooksInFolder(run.folderPaths.bookFolderPath);
+					should(bookTreeViewProvider.books.length).equal(1, 'Should have loaded only one book');
+
+					validateIsBook(bookTreeViewProvider.books[0]);
+				});
+
+				it('should include only notebooks when opening notebooks folder', async () => {
+					await bookTreeViewProvider.loadNotebooksInFolder(run.folderPaths.notebookFolderPath);
+					should(bookTreeViewProvider.books.length).equal(1, 'Should have loaded only one notebook');
+
+					validateIsNotebook(bookTreeViewProvider.books[0]);
+				});
+
+				afterEach(async function (): Promise<void> {
+					let bookItems = await bookTreeViewProvider.getChildren();
+					await Promise.all(bookItems.map(bookItem => bookTreeViewProvider.closeBook(bookItem)));
+				});
+
+				after(async function (): Promise<void> {
+					if (await exists(rootFolderPath)) {
+						await promisify(rimraf)(rootFolderPath);
+					}
+				});
+
+				let validateIsBook = (book: BookModel) => {
+					should(book.isNotebook).be.false();
+					should(book.bookItems.length).equal(1);
+
+					let bookItem = book.bookItems[0];
+
+					let bookDetails = bookItem.book;
+					should(bookDetails.type).equal(BookTreeItemType.Book);
+					should(bookDetails.title).equal(run.contents.bookTitle);
+					should(bookDetails.contentPath).equal(run.folderPaths.tableOfContentsFile.replace(/\\/g, '/'));
+					should(bookDetails.root).equal(run.folderPaths.bookFolderPath.replace(/\\/g, '/'));
+					should(bookDetails.tableOfContents.sections).not.equal(undefined);
+					should(bookDetails.page).not.equal(undefined);
+				};
+
+				let validateIsNotebook = (book: BookModel) => {
+					should(book.isNotebook).be.true();
+					should(book.bookItems.length).equal(1);
+
+					let bookItem = book.bookItems[0];
+					should(book.getAllNotebooks().get(vscode.Uri.file(run.folderPaths.standaloneNotebookFile).fsPath)).equal(bookItem);
+
+					let bookDetails = bookItem.book;
+					should(bookDetails.type).equal(BookTreeItemType.Notebook);
+					should(bookDetails.title).equal(run.contents.standaloneNotebookTitle);
+					should(bookDetails.contentPath).equal(run.folderPaths.standaloneNotebookFile.replace(/\\/g, '/'));
+					should(bookDetails.root).equal(run.folderPaths.notebookFolderPath.replace(/\\/g, '/'));
+					should(bookDetails.tableOfContents.sections).equal(undefined);
+					should(bookDetails.page.sections).equal(undefined);
+				};
+			});
 		});

-		it('should show error if notebook or markdown file is missing', async function (): Promise<void> {
-			let books: BookTreeItem[] = bookTreeViewProvider.currentBook.bookItems;
-			let children = await bookTreeViewProvider.currentBook.getSections({ sections: [] }, books[0].sections, rootFolderPath);
-			should(bookTreeViewProvider.currentBook.errorMessage).equal('Missing file : Notebook1');
-			// rest of book should be detected correctly even with a missing file
-			equalBookItems(children[0], expectedNotebook2);
-		});
-
-		this.afterAll(async function (): Promise<void> {
-			if (await exists(rootFolderPath)) {
-				await promisify(rimraf)(rootFolderPath);
-			}
-		});
-	});
-
-	describe('BookTreeViewProvider.Commands', function (): void {
-		let rootFolderPath: string;
-		let tableOfContentsFile: string;
-		let bookTreeViewProvider: BookTreeViewProvider;
-
-		this.beforeAll(async () => {
-			rootFolderPath = path.join(os.tmpdir(), `BookTestData_${uuid.v4()}`);
-			let dataFolderPath = path.join(rootFolderPath, '_data');
-			let contentFolderPath = path.join(rootFolderPath, 'content');
-			let configFile = path.join(rootFolderPath, '_config.yml');
-			tableOfContentsFile = path.join(dataFolderPath, 'toc.yml');
-			let notebook1File = path.join(contentFolderPath, 'notebook1.ipynb');
-			let notebook2File = path.join(contentFolderPath, 'notebook2.ipynb');
-			let markdownFile = path.join(contentFolderPath, 'readme.md');
-			await fs.mkdir(rootFolderPath);
-			await fs.mkdir(dataFolderPath);
-			await fs.mkdir(contentFolderPath);
-			await fs.writeFile(configFile, 'title: Test Book');
-			await fs.writeFile(tableOfContentsFile, '- title: Home\n  url: /readme\n- title: Notebook1\n  url: /notebook1\n- title: Notebook2\n  url: /notebook2');
-			await fs.writeFile(notebook1File, '');
-			await fs.writeFile(notebook2File, '');
-			await fs.writeFile(markdownFile, '');
-
-			const mockExtensionContext = new MockExtensionContext();
-			bookTreeViewProvider = new BookTreeViewProvider([], mockExtensionContext, false, 'bookTreeView', NavigationProviders.NotebooksNavigator);
-			let errorCase = new Promise((resolve, reject) => setTimeout(() => resolve(), 5000));
-			await Promise.race([bookTreeViewProvider.initialized, errorCase.then(() => { throw new Error('BookTreeViewProvider did not initialize in time'); })]);
-		});
-
-		afterEach(async function (): Promise<void> {
-			sinon.restore();
-			await vscode.commands.executeCommand('workbench.action.closeAllEditors');
-		});
-
-		it('should add book and initialize book on openBook', async () => {
-			should(bookTreeViewProvider.books.length).equal(0, 'Invalid books on initialize.');
-
-			let showPreviewSpy = sinon.spy(bookTreeViewProvider, 'showPreviewFile');
-
-			await bookTreeViewProvider.openBook(rootFolderPath);
-			should(bookTreeViewProvider.books.length).equal(1, 'Failed to initialize the book on open');
-			should(showPreviewSpy.notCalled).be.true('Should not call showPreviewFile when showPreview isn\' true');
-		});
-
-		it('openMarkdown should open markdown in the editor', async () => {
-			let executeCommandSpy = sinon.spy(vscode.commands, 'executeCommand');
-			let notebookPath = path.join(rootFolderPath, 'content', 'readme.md');
-			bookTreeViewProvider.openMarkdown(notebookPath);
-			should(executeCommandSpy.calledWith('markdown.showPreview')).be.true('openMarkdown should have called markdown.showPreview');
-		});
-
-		// TODO: Need to investigate why it's failing on linux.
-		it.skip('openNotebook should open notebook in the editor', async () => {
-			let showNotebookSpy = sinon.spy(azdata.nb, 'showNotebookDocument');
-			let notebookPath = path.join(rootFolderPath, 'content', 'notebook2.ipynb');
-			await bookTreeViewProvider.openNotebook(notebookPath);
-			should(showNotebookSpy.calledWith(vscode.Uri.file(notebookPath))).be.true(`Should have opened the notebook from ${notebookPath} in the editor.`);
-		});
-
-		it('openNotebookAsUntitled should open a notebook as untitled file in the editor', async () => {
-			let notebookPath = path.join(rootFolderPath, 'content', 'notebook2.ipynb');
-			await bookTreeViewProvider.openNotebookAsUntitled(notebookPath);
-			should(azdata.nb.notebookDocuments.find(doc => doc.uri.scheme === 'untitled')).not.be.undefined();
-		});
-
-		it('openExternalLink should open link', async () => {
-			let executeCommandSpy = sinon.spy(vscode.commands, 'executeCommand');
-			let notebookPath = path.join(rootFolderPath, 'content', 'readme.md');
-			bookTreeViewProvider.openMarkdown(notebookPath);
-			should(executeCommandSpy.calledWith('markdown.showPreview')).be.true('openMarkdown should have called markdown.showPreview');
-		});
-
-		it('should call showPreviewFile on openBook when showPreview flag is set', async () => {
-			await bookTreeViewProvider.closeBook(bookTreeViewProvider.books[0].bookItems[0]);
-			let showPreviewSpy = sinon.spy(bookTreeViewProvider, 'showPreviewFile');
-
-			await bookTreeViewProvider.openBook(rootFolderPath, undefined, true);
-			should(bookTreeViewProvider.books.length).equal(1, 'Failed to initialize the book on open');
-			should(showPreviewSpy.calledOnce).be.true('Should have called showPreviewFile.');
-		});
-
-		it('should add book when bookPath contains special characters on openBook', async () => {
-			let rootFolderPath2 = path.join(os.tmpdir(), `BookTestData(1)_${uuid.v4()}`);
-			let dataFolderPath2 = path.join(rootFolderPath2, '_data');
-			let contentFolderPath2 = path.join(rootFolderPath2, 'content');
-			let configFile2 = path.join(rootFolderPath2, '_config.yml');
-			let tableOfContentsFile2 = path.join(dataFolderPath2, 'toc.yml');
-			let notebook2File2 = path.join(contentFolderPath2, 'notebook2.ipynb');
-			await fs.mkdir(rootFolderPath2);
-			await fs.mkdir(dataFolderPath2);
-			await fs.mkdir(contentFolderPath2);
-			await fs.writeFile(configFile2, 'title: Test Book');
-			await fs.writeFile(tableOfContentsFile2, '- title: Notebook1\n  url: /notebook1\n- title: Notebook2\n  url: /notebook2');
-			await fs.writeFile(notebook2File2, '');
-
-			await bookTreeViewProvider.openBook(rootFolderPath2);
-			should(bookTreeViewProvider.books.length).equal(2, 'Failed to initialize the book on open');
-
-			await promisify(rimraf)(rootFolderPath2);
-		});
-
-		it('should get notebook path with untitled schema on openNotebookAsUntitled', async () => {
-			let notebookUri = bookTreeViewProvider.getUntitledNotebookUri(path.join(rootFolderPath, 'content', 'notebook2.ipynb'));
-			should(notebookUri.scheme).equal('untitled', 'Failed to get untitled uri of the resource');
-		});
-
-		it('openNotebookFolder without folderPath should prompt for folder path and invoke loadNotebooksInFolder', async () => {
-			sinon.stub(vscode.window, 'showOpenDialog').returns(Promise.resolve([vscode.Uri.file(rootFolderPath)]));
-			let loadNotebooksSpy = sinon.spy(bookTreeViewProvider, 'loadNotebooksInFolder');
-			await bookTreeViewProvider.openNotebookFolder();
-
-			should(loadNotebooksSpy.calledWith(rootFolderPath)).be.true('openNotebookFolder should have called loadNotebooksInFolder passing the folderPath');
-		});
-
-		it('openNotebookFolder with folderPath shouldn\'t prompt for folder path but invoke loadNotebooksInFolder with the provided folderPath', async () => {
-			let showOpenDialogSpy = sinon.spy(vscode.window, 'showOpenDialog');
-			let loadNotebooksSpy = sinon.spy(bookTreeViewProvider, 'loadNotebooksInFolder');
-			await bookTreeViewProvider.openNotebookFolder(rootFolderPath);
-
-			should(showOpenDialogSpy.notCalled).be.true('openNotebookFolder with folderPath shouldn\'t prompt to select folder');
-			should(loadNotebooksSpy.calledOnce).be.true('openNotebookFolder should have called loadNotebooksInFolder');
-		});
-
-		it('openNewBook should prompt for notebook path and invoke openBook', async () => {
-			sinon.stub(vscode.window, 'showOpenDialog').returns(Promise.resolve([vscode.Uri.file(rootFolderPath)]));
-			let openBookSpy = sinon.spy(bookTreeViewProvider, 'openBook');
-			await bookTreeViewProvider.openNewBook();
-
-			should(openBookSpy.calledOnce).be.true('openNewBook should have called openBook');
-		});
-
-		it('searchJupyterBooks should call command that opens Search view', async () => {
-			let executeCommandSpy = sinon.spy(vscode.commands, 'executeCommand');
-			await bookTreeViewProvider.searchJupyterBooks(bookTreeViewProvider.books[0].bookItems[0]);
-			should(executeCommandSpy.calledWith('workbench.action.findInFiles')).be.true('searchJupyterBooks should have called command to open Search view');
-		});
-
-		it('saveJupyterBooks should prompt location and openBook', async () => {
-			let saveFolderPath = path.join(os.tmpdir(), `Book_${uuid.v4()}`);
-			await fs.mkdir(saveFolderPath);
-			sinon.stub(vscode.window, 'showOpenDialog').returns(Promise.resolve([vscode.Uri.file(saveFolderPath)]));
-			let executeCommandSpy = sinon.spy(vscode.commands, 'executeCommand');
-			await bookTreeViewProvider.saveJupyterBooks();
-			should(executeCommandSpy.calledWith('bookTreeView.openBook')).be.true('saveJupyterBooks should have called command openBook after saving');
-
-			await promisify(rimraf)(saveFolderPath);
-		});
-
-		it('should remove book on closeBook', async () => {
-			let length: number = bookTreeViewProvider.books.length;
-			await bookTreeViewProvider.closeBook(bookTreeViewProvider.books[0].bookItems[0]);
-			should(bookTreeViewProvider.books.length).equal(length - 1, 'Failed to remove the book on close');
-		});
-
-		this.afterAll(async function (): Promise<void> {
-			if (await exists(rootFolderPath)) {
-				await promisify(rimraf)(rootFolderPath);
-			}
-		});
-	});
-
-	describe('BookTreeViewProvider.openNotebookFolder', function (): void {
-		let rootFolderPath: string;
-		let bookFolderPath: string;
-		let bookTitle: string;
-		let notebookFolderPath: string;
-		let tableOfContentsFile: string;
-		let standaloneNotebookTitle: string;
-		let standaloneNotebookFile: string;
-		let bookTreeViewProvider: BookTreeViewProvider;
-
-		this.beforeAll(async () => {
-			rootFolderPath = path.join(os.tmpdir(), `BookFolderTest_${uuid.v4()}`);
-			bookFolderPath = path.join(rootFolderPath, 'BookTestData');
-			let dataFolderPath = path.join(bookFolderPath, '_data');
-			let contentFolderPath = path.join(bookFolderPath, 'content');
-			let configFile = path.join(bookFolderPath, '_config.yml');
-			tableOfContentsFile = path.join(dataFolderPath, 'toc.yml');
-			let bookNotebookFile = path.join(contentFolderPath, 'notebook1.ipynb');
-			notebookFolderPath = path.join(rootFolderPath, 'NotebookTestData');
-			standaloneNotebookTitle = 'notebook2';
-			standaloneNotebookFile = path.join(notebookFolderPath, `${standaloneNotebookTitle}.ipynb`);
-			await fs.mkdir(rootFolderPath);
-			await fs.mkdir(bookFolderPath);
-			await fs.mkdir(dataFolderPath);
-			await fs.mkdir(contentFolderPath);
-			await fs.mkdir(notebookFolderPath);
-			bookTitle = 'Test Book';
-			await fs.writeFile(configFile, `title: ${bookTitle}`);
-			await fs.writeFile(tableOfContentsFile, '- title: Notebook1\n  url: /notebook1');
-			await fs.writeFile(bookNotebookFile, '');
-			await fs.writeFile(standaloneNotebookFile, '');
-
-			const mockExtensionContext = new MockExtensionContext();
-			bookTreeViewProvider = new BookTreeViewProvider([], mockExtensionContext, false, 'bookTreeView', NavigationProviders.NotebooksNavigator);
-			let errorCase = new Promise((resolve, reject) => setTimeout(() => resolve(), 5000));
-			await Promise.race([bookTreeViewProvider.initialized, errorCase.then(() => { throw new Error('BookTreeViewProvider did not initialize in time'); })]);
-		});
-
-		it('should include books and notebooks when opening parent folder', async () => {
-			await bookTreeViewProvider.loadNotebooksInFolder(rootFolderPath);
-			should(bookTreeViewProvider.books.length).equal(2, 'Should have loaded a book and a notebook');
-
-			validateIsBook(bookTreeViewProvider.books[0]);
-			validateIsNotebook(bookTreeViewProvider.books[1]);
-		});
-
-		it('should include only books when opening books folder', async () => {
-			await bookTreeViewProvider.loadNotebooksInFolder(bookFolderPath);
-			should(bookTreeViewProvider.books.length).equal(1, 'Should have loaded only one book');
-
-			validateIsBook(bookTreeViewProvider.books[0]);
-		});
-
-		it('should include only notebooks when opening notebooks folder', async () => {
-			await bookTreeViewProvider.loadNotebooksInFolder(notebookFolderPath);
-			should(bookTreeViewProvider.books.length).equal(1, 'Should have loaded only one notebook');
-
-			validateIsNotebook(bookTreeViewProvider.books[0]);
-		});
-
-		this.afterEach(async function (): Promise<void> {
-			let bookItems = await bookTreeViewProvider.getChildren();
-			await Promise.all(bookItems.map(bookItem => bookTreeViewProvider.closeBook(bookItem)));
-		});
-
-		this.afterAll(async function (): Promise<void> {
-			if (await exists(rootFolderPath)) {
-				await promisify(rimraf)(rootFolderPath);
-			}
-		});
-
-		let validateIsBook = (book: BookModel) => {
-			should(book.isNotebook).be.false();
-			should(book.bookItems.length).equal(1);
-
-			let bookItem = book.bookItems[0];
-
-			let bookDetails = bookItem.book;
-			should(bookDetails.type).equal(BookTreeItemType.Book);
-			should(bookDetails.title).equal(bookTitle);
-			should(bookDetails.contentPath).equal(tableOfContentsFile.replace(/\\/g, '/'));
-			should(bookDetails.root).equal(bookFolderPath.replace(/\\/g, '/'));
-			should(bookDetails.tableOfContents.sections).not.equal(undefined);
-			should(bookDetails.page).not.equal(undefined);
-		};
-
-		let validateIsNotebook = (book: BookModel) => {
-			should(book.isNotebook).be.true();
-			should(book.bookItems.length).equal(1);
-
-			let bookItem = book.bookItems[0];
-			should(book.getAllNotebooks().get(vscode.Uri.file(standaloneNotebookFile).fsPath)).equal(bookItem);
-
-			let bookDetails = bookItem.book;
-			should(bookDetails.type).equal(BookTreeItemType.Notebook);
-			should(bookDetails.title).equal(standaloneNotebookTitle);
-			should(bookDetails.contentPath).equal(standaloneNotebookFile.replace(/\\/g, '/'));
-			should(bookDetails.root).equal(notebookFolderPath.replace(/\\/g, '/'));
-			should(bookDetails.tableOfContents.sections).equal(undefined);
-			should(bookDetails.page.sections).equal(undefined);
-		};
 	});
 });