it("RemoveSourcesCommand Test", () => {
const conn1 = "conn1";
const conn2 = "conn2";
const path1 = "table=node1";
const path2 = "table=node2";
const node1 = SchemaNode.create( { connectionName: "conn1", path: path1 } );
const node2 = SchemaNode.create( { connectionName: "conn2", path: path2 } );
const temp = CommandFactory.createRemoveSourcesCommand( [ node1, node2 ], "ident" );
expect( temp instanceof RemoveSourcesCommand ).toBe( true );
const cmd = temp as RemoveSourcesCommand;
expect( cmd.id ).toBe( RemoveSourcesCommand.id );
expect( cmd.args ).not.toBeNull();
expect( cmd.args.size ).toBe( 2 );
const expectedSrcPaths = "connection=" + conn1 + "/" + path1 + ", connection=" + conn2 + "/" + path2;
const expectedFull = expectedSrcPaths + ", ObjectId=ident";
expect( cmd.getArg( RemoveSourcesCommand.removedSourcePaths ) ).toEqual( expectedSrcPaths );
expect( cmd.toString() ).toEqual( "RemoveSourcesCommand, removedSourcePaths=" + expectedFull );
expect( cmd.isUndoable() ).toBe( true );
const json = cmd.toJSON();
const tempRoundtrip = CommandFactory.decode( json );
expect( tempRoundtrip instanceof RemoveSourcesCommand ).toBe( true );
const roundtrip = tempRoundtrip as RemoveSourcesCommand;
expect( roundtrip.id ).toBe( cmd.id );
expect( roundtrip.args.size ).toBe( cmd.args.size );
expect( roundtrip.getArg( RemoveSourcesCommand.removedSourcePaths ) ).toBe( cmd.getArg( RemoveSourcesCommand.removedSourcePaths ) );
});
it("UpdateViewDescriptionCommand Test", () => {
const temp = CommandFactory.createUpdateViewDescriptionCommand( "theNewDescription",
"theOldDescription" );
expect( temp instanceof UpdateViewDescriptionCommand ).toBe( true );
const cmd = temp as UpdateViewDescriptionCommand;
expect( cmd.id ).toBe( UpdateViewDescriptionCommand.id );
expect( cmd.args ).not.toBeNull();
expect( cmd.args.size ).toBe( 2 );
expect( cmd.getArg( UpdateViewDescriptionCommand.newDescription ) ).toEqual( "theNewDescription" );
expect( cmd.getArg( UpdateViewDescriptionCommand.oldDescription ) ).toEqual( "theOldDescription" );
expect( cmd.toString() ).toEqual( "UpdateViewDescriptionCommand, newDescription=theNewDescription, oldDescription=theOldDescription" );
expect( cmd.isUndoable() ).toBe( true );
const json = cmd.toJSON();
const tempRoundtrip = CommandFactory.decode( json );
expect( tempRoundtrip instanceof UpdateViewDescriptionCommand ).toBe( true );
const roundtrip = tempRoundtrip as UpdateViewDescriptionCommand;
expect( roundtrip.id ).toBe( cmd.id );
expect( roundtrip.args.size ).toBe( cmd.args.size );
expect( roundtrip.getArg( UpdateViewDescriptionCommand.newDescription ) )
.toBe( cmd.getArg( UpdateViewDescriptionCommand.newDescription ) );
expect( roundtrip.getArg( UpdateViewDescriptionCommand.oldDescription ) )
.toBe( cmd.getArg( UpdateViewDescriptionCommand.oldDescription ) );
});
it( "shouldConvertToJsonCorrectly" , () => {
const undoMgr = new UndoManager();
// add update name command
let cmd = CommandFactory.createUpdateViewNameCommand( "newName", "oldName");
let undoable = CommandFactory.createUndoable( cmd as Command ) ;
undoMgr.add( undoable as Undoable );
// add update description command
cmd = CommandFactory.createUpdateViewDescriptionCommand( "newDescription", "oldDescription");
undoable = CommandFactory.createUndoable( cmd as Command ) ;
undoMgr.add( undoable as Undoable );
// should include both undoables
expect( undoMgr.toJSON() ).not.toBe( null );
expect( undoMgr.toJSON()[ UndoManager.undoables ] ).not.toBe( null );
expect( undoMgr.toJSON()[ UndoManager.undoables ] instanceof Array ).toBe( true );
const undoables = undoMgr.toJSON()[ UndoManager.undoables ] as Array< any >;
expect( undoables.length ).toBe( 2 );
// move the pointer to the left
undoMgr.popUndoCommand();
expect( undoMgr.toArray().length).toBe( 1 );
expect( undoMgr.toArray().length).toBe( 1 );
} );
it("AddSourcesCommand Undo Test", () => {
const node1 = SchemaNode.create( { connectionName: "conn1", path: "table=node1" } );
const node2 = SchemaNode.create( { connectionName: "conn2", path: "table=node2" } );
const tempCmd = CommandFactory.createAddSourcesCommand( [ node1, node2 ], "ident" );
expect( tempCmd instanceof AddSourcesCommand ).toBe( true );
const cmd = tempCmd as AddSourcesCommand;
const tempUndoCmd = CommandFactory.createUndoCommand( cmd );
expect( tempUndoCmd instanceof RemoveSourcesCommand ).toBe( true );
const undoCmd = tempUndoCmd as RemoveSourcesCommand;
expect( undoCmd ).not.toBeNull();
expect( undoCmd.id ).toBe( RemoveSourcesCommand.id );
expect( undoCmd.args.size ).toBe( 2 );
expect( undoCmd.getArg( RemoveSourcesCommand.removedSourcePaths ) ).toEqual( cmd.getArg( AddSourcesCommand.addedSourcePaths ) );
});
it("UpdateViewNameCommand Undo Test", () => {
const tempCmd = CommandFactory.createUpdateViewNameCommand( "theNewName",
"theOldName" );
expect( tempCmd instanceof UpdateViewNameCommand ).toBe( true );
const cmd = tempCmd as UpdateViewNameCommand;
const tempUndoCmd = CommandFactory.createUndoCommand( cmd );
expect( tempUndoCmd instanceof UpdateViewNameCommand ).toBe( true );
const undoCmd = tempUndoCmd as UpdateViewNameCommand;
expect( undoCmd ).not.toBeNull();
expect( undoCmd.id ).toBe( UpdateViewNameCommand.id );
expect( undoCmd.args.size ).toBe( 2 );
expect( undoCmd.getArg( UpdateViewNameCommand.newName ) ).toBe( cmd.getArg( UpdateViewNameCommand.oldName ) );
expect( undoCmd.getArg( UpdateViewNameCommand.oldName ) ).toBe( cmd.getArg( UpdateViewNameCommand.newName ) );
});
it("NoOpCommand Test", () => {
const cmd = CommandFactory.createNoOpCommand();
expect( cmd.id ).toBe( NoOpCommand.id );
expect( cmd.args ).not.toBeNull();
expect( cmd.args.size ).toBe( 0 );
expect( cmd.toString() ).toEqual( "NoOpCommand, []" );
expect( cmd.isUndoable() ).toBe( false );
});
it( "shouldClear", () => {
const undoMgr = new UndoManager();
const cmd = CommandFactory.createUpdateViewNameCommand( "newName", "oldName");
const undoable = CommandFactory.createUndoable( cmd as Command ) ;
undoMgr.add( undoable as Undoable );
expect( undoMgr.canRedo() ).toBe( false );
expect( undoMgr.canUndo() ).toBe( true );
expect( () => { undoMgr.peekRedoCommand(); } ).toThrow();
expect( () => { undoMgr.popRedoCommand(); } ).toThrow();
expect( undoMgr.peekUndoCommand() instanceof Command ).toBe( true );
expect( undoMgr.toArray().length ).toBe( 1 );
// now pop
expect( undoMgr.popUndoCommand() instanceof Command ).toBe( true );
expect( undoMgr.canRedo() ).toBe( true );
expect( undoMgr.canUndo() ).toBe( false );
expect( () => { undoMgr.peekUndoCommand(); } ).toThrow();
expect( () => { undoMgr.popUndoCommand(); } ).toThrow();
expect( undoMgr.peekRedoCommand() instanceof Command ).toBe( true );
expect( undoMgr.toArray().length ).toBe( 1 );
expect( undoMgr.toJSON()[ "undoables"].length ).toBe( 1 );
} );
it("should create", () => {
console.log( "========== [Undoable] should create" );
result = CommandFactory.decodeUndoable(
{
"undo": {
"id": "UpdateViewNameCommand",
"args": { "oldName": "v", "newName": "" }
},
"redo": {
"id": "UpdateViewNameCommand",
"args": { "oldName": "b", "newName": "v" }
}
}
);
if ( result instanceof Undoable ) {
const undoable = result as Undoable;
expect( undoable.undoCommand.id ).toEqual( UpdateViewNameCommand.id );
expect( undoable.redoCommand.id ).toEqual( UpdateViewNameCommand.id );
} else {
fail("Unable to create Undoable");
}
});
it("NoOpCommand Undo Test", () => {
const cmd = CommandFactory.createNoOpCommand();
const error = CommandFactory.createUndoCommand( cmd );
expect( error instanceof Error).toBe( true );
});