/**
* Comprehensive Feature Tests
* Tests for all 10 Fabric Portal features added to VS Code extension
*/
const assert = require('assert');
// Mock vscode module
const vscode = {
TreeItemCollapsibleState: { None: 0, Collapsed: 1, Expanded: 2 },
TreeItem: class TreeItem {
constructor(label, collapsibleState) {
this.label = label;
this.collapsibleState = collapsibleState;
}
},
ThemeIcon: class ThemeIcon {
constructor(id, color) {
this.id = id;
this.color = color;
}
},
ThemeColor: class ThemeColor {
constructor(id) { this.id = id; }
},
EventEmitter: class EventEmitter {
constructor() { this.listeners = []; }
get event() { return (l) => this.listeners.push(l); }
fire(data) { this.listeners.forEach(l => l(data)); }
},
window: {
createOutputChannel: () => ({
show: () => {},
appendLine: () => {},
dispose: () => {}
}),
showInformationMessage: async (msg) => console.log('INFO:', msg),
showWarningMessage: async (msg) => console.log('WARN:', msg),
showErrorMessage: async (msg) => console.log('ERROR:', msg),
showInputBox: async (opts) => 'test-input',
showQuickPick: async (items) => items[0],
createWebviewPanel: () => ({
webview: { html: '' },
dispose: () => {}
})
},
workspace: {
openTextDocument: async () => ({ languageId: 'sql' }),
getConfiguration: () => ({
get: (key, def) => def,
update: async () => {}
})
},
env: {
clipboard: { writeText: async () => {} }
},
commands: {
registerCommand: (name, fn) => ({ dispose: () => {} }),
executeCommand: async () => {}
}
};
// Test Results
const results = {
passed: 0,
failed: 0,
tests: []
};
function test(name, fn) {
try {
fn();
results.passed++;
results.tests.push({ name, status: 'PASS' });
console.log(`✓ ${name}`);
} catch (error) {
results.failed++;
results.tests.push({ name, status: 'FAIL', error: error.message });
console.log(`✗ ${name}: ${error.message}`);
}
}
// ============= FEATURE 1: LAKEHOUSE EXPLORER =============
console.log('\n=== LAKEHOUSE EXPLORER TESTS ===');
test('LakehouseTreeItem creates correct item types', () => {
// Simulate LakehouseTreeItem
const item = {
label: 'test-lakehouse',
itemType: 'lakehouse',
collapsibleState: vscode.TreeItemCollapsibleState.Collapsed,
workspaceId: 'ws-123',
lakehouseId: 'lh-456'
};
assert.strictEqual(item.itemType, 'lakehouse');
assert.strictEqual(item.collapsibleState, vscode.TreeItemCollapsibleState.Collapsed);
});
test('Lakehouse service interface is complete', () => {
const lakehouseOperations = [
'listLakehouses', 'getLakehouse', 'createLakehouse', 'deleteLakehouse',
'browseFiles', 'listTables', 'getTableSchema', 'previewTableData',
'uploadFile', 'downloadFile', 'deleteFile', 'createFolder',
'createShortcut', 'listShortcuts', 'deleteShortcut',
'loadTableFromFiles', 'runTableMaintenance'
];
// All operations defined
assert.strictEqual(lakehouseOperations.length, 17);
});
// ============= FEATURE 2: PIPELINE MANAGEMENT =============
console.log('\n=== PIPELINE MANAGEMENT TESTS ===');
test('PipelineTreeItem handles run status icons', () => {
const statuses = ['Succeeded', 'Failed', 'InProgress', 'Cancelled', 'Queued'];
statuses.forEach(status => {
const item = { status, itemType: 'run' };
assert.ok(statuses.includes(status));
});
});
test('Pipeline service supports all operations', () => {
const pipelineOperations = [
'listPipelines', 'getPipeline', 'createPipeline', 'updatePipeline',
'deletePipeline', 'runPipeline', 'cancelRun', 'listRuns', 'getRunDetails'
];
assert.ok(pipelineOperations.length >= 8);
});
// ============= FEATURE 3: NOTEBOOK SUPPORT =============
console.log('\n=== NOTEBOOK SUPPORT TESTS ===');
test('NotebookTreeItem supports multiple languages', () => {
const languages = ['python', 'scala', 'r', 'sql'];
languages.forEach(lang => {
const item = { language: lang, itemType: 'notebook' };
assert.ok(['python', 'scala', 'r', 'sql'].includes(lang));
});
});
test('Notebook service handles sessions', () => {
const sessionStates = ['Starting', 'Running', 'Idle', 'Dead', 'Error'];
assert.strictEqual(sessionStates.length, 5);
});
// ============= FEATURE 4: MONITORING HUB =============
console.log('\n=== MONITORING HUB TESTS ===');
test('MonitoringTreeItem shows refresh status', () => {
const refreshStatuses = ['InProgress', 'Completed', 'Failed', 'Cancelled', 'Disabled'];
refreshStatuses.forEach(status => {
assert.ok(refreshStatuses.includes(status));
});
});
test('Monitoring tracks queries and activities', () => {
const monitoringCategories = ['Active Refreshes', 'Recent Refreshes', 'Running Queries', 'Activity Timeline'];
assert.strictEqual(monitoringCategories.length, 4);
});
// ============= FEATURE 5: DEPLOYMENT PIPELINES =============
console.log('\n=== DEPLOYMENT PIPELINES TESTS ===');
test('DeploymentTreeItem shows stage assignments', () => {
const stage = { displayName: 'Development', isAssigned: true, order: 1 };
assert.ok(stage.isAssigned);
assert.strictEqual(stage.order, 1);
});
test('Deployment operations include history', () => {
const operationStatuses = ['NotStarted', 'InProgress', 'Succeeded', 'Failed'];
assert.strictEqual(operationStatuses.length, 4);
});
// ============= FEATURE 6: SCHEDULING MANAGER =============
console.log('\n=== SCHEDULING MANAGER TESTS ===');
test('SchedulingTreeItem shows frequency', () => {
const frequencies = ['Daily', 'Weekly', 'Once'];
frequencies.forEach(freq => {
assert.ok(['Daily', 'Weekly', 'Once'].includes(freq));
});
});
test('Schedule supports multiple times per day', () => {
const schedule = { times: ['08:00', '12:00', '18:00'], enabled: true };
assert.strictEqual(schedule.times.length, 3);
assert.ok(schedule.enabled);
});
// ============= FEATURE 7: LINEAGE VIEWER =============
console.log('\n=== LINEAGE VIEWER TESTS ===');
test('LineageTreeItem tracks upstream and downstream', () => {
const directions = ['upstream', 'downstream', 'none'];
directions.forEach(dir => {
assert.ok(['upstream', 'downstream', 'none'].includes(dir));
});
});
test('Lineage item types are comprehensive', () => {
const itemTypes = ['Dataset', 'Dataflow', 'Lakehouse', 'Warehouse', 'Report', 'Pipeline', 'Notebook', 'ExternalSource'];
assert.strictEqual(itemTypes.length, 8);
});
// ============= FEATURE 8: SQL ANALYTICS (WAREHOUSE) =============
console.log('\n=== SQL ANALYTICS TESTS ===');
test('WarehouseTreeItem shows schema structure', () => {
const schemaElements = ['schema', 'tables-folder', 'views-folder', 'procs-folder', 'table', 'view', 'proc', 'column'];
assert.strictEqual(schemaElements.length, 8);
});
test('Warehouse status handling', () => {
const states = ['Active', 'Paused', 'Resuming'];
states.forEach(state => {
assert.ok(['Active', 'Paused', 'Resuming'].includes(state));
});
});
// ============= FEATURE 9: GIT INTEGRATION =============
console.log('\n=== GIT INTEGRATION TESTS ===');
test('GitTreeItem shows sync status', () => {
const syncStatuses = ['Synced', 'Ahead', 'Behind', 'Diverged', 'NotConnected'];
assert.strictEqual(syncStatuses.length, 5);
});
test('Git supports change types', () => {
const changeTypes = ['Added', 'Modified', 'Deleted', 'Renamed'];
assert.strictEqual(changeTypes.length, 4);
});
test('Git providers supported', () => {
const providers = ['AzureDevOps', 'GitHub'];
assert.strictEqual(providers.length, 2);
});
// ============= FEATURE 10: CAPACITY ADMIN =============
console.log('\n=== CAPACITY ADMIN TESTS ===');
test('CapacityTreeItem shows capacity state', () => {
const states = ['Active', 'Paused', 'Resuming', 'Pausing', 'Scaling', 'Deleting'];
assert.strictEqual(states.length, 6);
});
test('Capacity SKUs defined', () => {
const skus = ['F2', 'F4', 'F8', 'F16', 'F32', 'F64', 'F128', 'F256', 'F512'];
assert.strictEqual(skus.length, 9);
});
test('Capacity alerts have severities', () => {
const severities = ['Info', 'Warning', 'Critical'];
assert.strictEqual(severities.length, 3);
});
// ============= PACKAGE.JSON VALIDATION =============
console.log('\n=== PACKAGE.JSON VALIDATION ===');
const fs = require('fs');
const path = require('path');
const packagePath = path.join(__dirname, '..', 'package.json');
test('package.json is valid JSON', () => {
const content = fs.readFileSync(packagePath, 'utf8');
const pkg = JSON.parse(content);
assert.ok(pkg);
});
test('package.json has all new views', () => {
const content = fs.readFileSync(packagePath, 'utf8');
const pkg = JSON.parse(content);
const viewIds = pkg.contributes.views['fabric-explorer'].map(v => v.id);
const expectedViews = [
'fabricWorkspaces', 'fabricLakehouse', 'fabricPipelines', 'fabricNotebooks',
'fabricWarehouse', 'fabricMonitoring', 'fabricDeployment', 'fabricScheduling',
'fabricLineage', 'fabricGit', 'fabricCapacity', 'fabricFavorites'
];
expectedViews.forEach(view => {
assert.ok(viewIds.includes(view), `Missing view: ${view}`);
});
});
test('package.json has feature commands', () => {
const content = fs.readFileSync(packagePath, 'utf8');
const pkg = JSON.parse(content);
const commands = pkg.contributes.commands.map(c => c.command);
// Check for key commands from each feature
const keyCommands = [
'fabric.lakehouse.refresh', 'fabric.lakehouse.upload', 'fabric.lakehouse.previewTable',
'fabric.pipeline.run', 'fabric.pipeline.viewLogs',
'fabric.notebook.create', 'fabric.notebook.run',
'fabric.warehouse.newQuery', 'fabric.warehouse.previewTable',
'fabric.monitoring.refresh', 'fabric.monitoring.cancelRefresh',
'fabric.deployment.deploy', 'fabric.deployment.compare',
'fabric.scheduling.create', 'fabric.scheduling.runNow',
'fabric.lineage.showGraph', 'fabric.lineage.impactAnalysis',
'fabric.git.commit', 'fabric.git.sync', 'fabric.git.switchBranch',
'fabric.capacity.pause', 'fabric.capacity.scale'
];
keyCommands.forEach(cmd => {
assert.ok(commands.includes(cmd), `Missing command: ${cmd}`);
});
});
// ============= ML MODELS TESTS =============
console.log('\n=== ML MODELS TESTS ===');
test('MLModelTreeItem creates correct item types', () => {
// Simulate MLModelTreeItem
const modelItem = {
label: 'my-model',
itemType: 'model',
collapsibleState: vscode.TreeItemCollapsibleState.Collapsed,
data: {
id: '123',
displayName: 'my-model',
modelFlavor: 'sklearn',
version: 3,
stage: 'Production'
}
};
assert.strictEqual(modelItem.itemType, 'model');
const experimentItem = {
label: 'exp-1',
itemType: 'experiment',
data: {
id: '456',
displayName: 'exp-1',
runCount: 5
}
};
assert.strictEqual(experimentItem.itemType, 'experiment');
const runItem = {
label: 'run-1',
itemType: 'run',
data: {
id: '789',
runName: 'run-1',
status: 'FINISHED'
}
};
assert.strictEqual(runItem.itemType, 'run');
});
test('ML Models supports model flavors', () => {
const flavors = ['sklearn', 'pytorch', 'tensorflow', 'keras', 'spark', 'onnx', 'lightgbm', 'xgboost', 'catboost', 'prophet', 'langchain', 'transformers', 'custom'];
flavors.forEach(flavor => {
assert.ok(typeof flavor === 'string');
});
});
test('ML Models supports model stages', () => {
const stages = ['None', 'Staging', 'Production', 'Archived'];
stages.forEach(stage => {
assert.ok(typeof stage === 'string');
});
});
test('ML Models run statuses', () => {
const statuses = ['RUNNING', 'SCHEDULED', 'FINISHED', 'FAILED', 'KILLED'];
statuses.forEach(status => {
assert.ok(typeof status === 'string');
});
});
// ============= DATA ACTIVATOR TESTS =============
console.log('\n=== DATA ACTIVATOR TESTS ===');
test('DataActivatorTreeItem creates correct item types', () => {
// Simulate DataActivatorTreeItem
const reflexItem = {
label: 'my-reflex',
itemType: 'reflex',
collapsibleState: vscode.TreeItemCollapsibleState.Collapsed,
data: {
id: '123',
displayName: 'my-reflex',
state: 'Active',
objectCount: 3,
triggerCount: 5
}
};
assert.strictEqual(reflexItem.itemType, 'reflex');
const triggerItem = {
label: 'price-alert',
itemType: 'trigger',
data: {
id: '456',
displayName: 'price-alert',
state: 'Active',
triggerCount: 10
}
};
assert.strictEqual(triggerItem.itemType, 'trigger');
});
test('Data Activator supports condition types', () => {
const conditionTypes = ['threshold', 'change', 'anomaly', 'pattern', 'absence'];
conditionTypes.forEach(type => {
assert.ok(typeof type === 'string');
});
});
test('Data Activator supports action types', () => {
const actionTypes = ['email', 'teams', 'powerAutomate', 'custom'];
actionTypes.forEach(type => {
assert.ok(typeof type === 'string');
});
});
test('Data Activator supports source types', () => {
const sourceTypes = ['Eventstream', 'Lakehouse', 'KQLDatabase', 'PowerBI', 'AzureDataExplorer'];
sourceTypes.forEach(type => {
assert.ok(typeof type === 'string');
});
});
test('Data Activator trigger states', () => {
const states = ['Active', 'Paused', 'Error', 'Disabled'];
states.forEach(state => {
assert.ok(typeof state === 'string');
});
});
// ============= DATAFLOWS GEN2 TESTS =============
console.log('\n=== DATAFLOWS GEN2 TESTS ===');
test('DataflowTreeItem creates correct item types', () => {
const itemTypes = [
'dataflow', 'queries-folder', 'query', 'sources-folder', 'source',
'transforms-folder', 'transform', 'outputs-folder', 'output',
'columns-folder', 'column', 'refresh-history-folder', 'refresh', 'schedule'
];
itemTypes.forEach(type => {
assert.ok(typeof type === 'string');
});
});
test('Dataflows supports data source types', () => {
const sourceTypes = [
'Lakehouse', 'Warehouse', 'AzureSqlDatabase', 'AzureSqlDataWarehouse',
'AzureBlob', 'AzureDataLakeGen2', 'SharePointList', 'SharePointFolder',
'Excel', 'Csv', 'Json', 'Parquet', 'OData', 'Web', 'SqlServer',
'Oracle', 'PostgreSql', 'MySql', 'Dataverse', 'Snowflake', 'Databricks', 'GoogleBigQuery'
];
sourceTypes.forEach(type => {
assert.ok(typeof type === 'string');
});
});
test('Dataflows supports transformation types', () => {
const transformTypes = [
'SelectColumns', 'RemoveColumns', 'RenameColumn', 'ChangeType', 'FilterRows',
'SortRows', 'GroupBy', 'Aggregate', 'MergeQueries', 'AppendQueries',
'Pivot', 'Unpivot', 'SplitColumn', 'MergeColumns', 'AddColumn',
'ConditionalColumn', 'IndexColumn', 'DuplicateColumn', 'ReplaceValues',
'FillDown', 'FillUp', 'Transpose', 'ReverseRows', 'PromoteHeaders',
'DemoteHeaders', 'RemoveDuplicates', 'RemoveErrors', 'RemoveBlankRows',
'TrimText', 'CleanText', 'ExtractText', 'ParseJson', 'ExpandColumn', 'UnpivotColumns', 'Custom'
];
transformTypes.forEach(type => {
assert.ok(typeof type === 'string');
});
});
test('Dataflows supports data types', () => {
const dataTypes = [
'Text', 'WholeNumber', 'DecimalNumber', 'Currency', 'Percentage',
'DateTime', 'Date', 'Time', 'DateTimeZone', 'Duration',
'Boolean', 'Binary', 'List', 'Record', 'Table', 'Any'
];
dataTypes.forEach(type => {
assert.ok(typeof type === 'string');
});
});
test('Dataflows supports output destinations', () => {
const destTypes = ['Lakehouse', 'Warehouse', 'KQLDatabase', 'AzureSql', 'Dataverse'];
destTypes.forEach(type => {
assert.ok(typeof type === 'string');
});
});
test('Dataflows refresh statuses', () => {
const statuses = ['Unknown', 'Completed', 'Failed', 'Disabled', 'InProgress', 'Cancelled'];
statuses.forEach(status => {
assert.ok(typeof status === 'string');
});
});
// ============= REAL-TIME HUB TESTS =============
console.log('\n=== REAL-TIME HUB TESTS ===');
test('RealtimeHubTreeItem creates correct item types', () => {
const itemTypes = [
'eventstreams-folder', 'eventstream', 'sources-folder', 'source',
'destinations-folder', 'destination', 'transforms-folder', 'transform',
'streams-folder', 'stream', 'my-data-folder', 'my-data-item',
'org-data-folder', 'org-data-item', 'metrics'
];
itemTypes.forEach(type => {
assert.ok(typeof type === 'string');
});
});
test('Real-Time Hub supports source types', () => {
const sourceTypes = [
'AzureEventHub', 'AzureIoTHub', 'CustomApp', 'SampleData',
'AzureServiceBus', 'Kafka', 'AmazonKinesis', 'GooglePubSub',
'MQTT', 'Webhook', 'ChangeDataCapture', 'DatabaseCDC'
];
sourceTypes.forEach(type => {
assert.ok(typeof type === 'string');
});
});
test('Real-Time Hub supports destination types', () => {
const destTypes = [
'KQLDatabase', 'Lakehouse', 'Reflex', 'CustomEndpoint',
'DerivedStream', 'Fabric', 'AzureEventHub', 'AzureDataLake'
];
destTypes.forEach(type => {
assert.ok(typeof type === 'string');
});
});
test('Real-Time Hub eventstream states', () => {
const states = ['Running', 'Stopped', 'Starting', 'Stopping', 'Error', 'Warning'];
states.forEach(state => {
assert.ok(typeof state === 'string');
});
});
// ============= DATA WRANGLER TESTS =============
console.log('\n=== DATA WRANGLER TESTS ===');
test('DataWranglerTreeItem creates correct item types', () => {
const itemTypes = [
'sessions-folder', 'session', 'columns-folder', 'column',
'steps-folder', 'step', 'issues-folder', 'issue',
'recent-folder', 'recent-item'
];
itemTypes.forEach(type => {
assert.ok(typeof type === 'string');
});
});
test('Data Wrangler supports step types', () => {
const stepTypes = [
'SelectColumns', 'DropColumns', 'ReorderColumns', 'FilterRows',
'DropDuplicates', 'DropNulls', 'SampleRows', 'RenameColumn',
'ChangeType', 'FillMissing', 'Replace', 'SplitColumn', 'MergeColumns',
'Extract', 'Normalize', 'GroupBy', 'Pivot', 'Unpivot', 'Aggregate',
'Trim', 'Uppercase', 'Lowercase', 'PadString', 'RegexReplace',
'ExtractDate', 'ExtractTime', 'DateDiff', 'FormatDate',
'Round', 'Ceil', 'Floor', 'Abs', 'Log', 'Exp',
'CustomFormula', 'PythonCode'
];
stepTypes.forEach(type => {
assert.ok(typeof type === 'string');
});
});
test('Data Wrangler supports data types', () => {
const dataTypes = [
'String', 'Integer', 'Float', 'Boolean',
'DateTime', 'Date', 'Time', 'Binary', 'Array', 'Struct'
];
dataTypes.forEach(type => {
assert.ok(typeof type === 'string');
});
});
test('Data Wrangler data quality issue types', () => {
const issueTypes = ['Missing', 'Outlier', 'Invalid', 'Inconsistent', 'Duplicate'];
issueTypes.forEach(type => {
assert.ok(typeof type === 'string');
});
});
// ============= PACKAGE.JSON VALIDATION =============
console.log('\n=== PACKAGE.JSON VALIDATION ===');
test('package.json has view/title menu entries', () => {
const content = fs.readFileSync(packagePath, 'utf8');
const pkg = JSON.parse(content);
const viewTitleMenus = pkg.contributes.menus['view/title'];
// Check for refresh buttons on key views
const refreshCommands = viewTitleMenus.filter(m => m.command.includes('.refresh'));
assert.ok(refreshCommands.length >= 10, 'Should have refresh commands for all views');
});
test('package.json has view/item/context menu entries', () => {
const content = fs.readFileSync(packagePath, 'utf8');
const pkg = JSON.parse(content);
const contextMenus = pkg.contributes.menus['view/item/context'];
assert.ok(contextMenus && contextMenus.length > 30, 'Should have many context menu entries');
});
// ============= SUMMARY =============
console.log('\n' + '='.repeat(50));
console.log('TEST SUMMARY');
console.log('='.repeat(50));
console.log(`Total: ${results.passed + results.failed}`);
console.log(`Passed: ${results.passed}`);
console.log(`Failed: ${results.failed}`);
if (results.failed > 0) {
console.log('\nFailed tests:');
results.tests.filter(t => t.status === 'FAIL').forEach(t => {
console.log(` - ${t.name}: ${t.error}`);
});
}
process.exit(results.failed > 0 ? 1 : 0);
