diff --git a/src/menu/node-menu.component.ts b/src/menu/node-menu.component.ts
index cbdeda72..5a48a99e 100644
--- a/src/menu/node-menu.component.ts
+++ b/src/menu/node-menu.component.ts
@@ -1,4 +1,4 @@
-import { Component, EventEmitter, Output, Renderer, Inject, OnDestroy, OnInit } from '@angular/core';
+import { Component, EventEmitter, Output, Renderer, Inject, OnDestroy, OnInit, ViewChild } from '@angular/core';
 import { NodeMenuService } from './node-menu.service';
 import { NodeMenuItemSelectedEvent, NodeMenuItemAction, NodeMenuAction } from './menu.events';
 import { isLeftButtonClicked, isEscapePressed } from '../utils/event.utils';
@@ -7,9 +7,9 @@ import { isLeftButtonClicked, isEscapePressed } from '../utils/event.utils';
   selector: 'node-menu',
   template: `
     <div class="node-menu">
-      <ul class="node-menu-content">
+      <ul class="node-menu-content" #menuContainer>
         <li class="node-menu-item" *ngFor="let menuItem of availableMenuItems"
-            (click)="onMenuItemSelected($event, menuItem)">
+          (click)="onMenuItemSelected($event, menuItem)">
           <div class="node-menu-item-icon {{menuItem.cssClass}}"></div>
           <span class="node-menu-item-value">{{menuItem.name}}</span>
         </li>
@@ -21,6 +21,8 @@ export class NodeMenuComponent implements OnInit, OnDestroy {
   @Output()
   public menuItemSelected: EventEmitter<NodeMenuItemSelectedEvent> = new EventEmitter<NodeMenuItemSelectedEvent>();
 
+  @ViewChild('menuContainer') public menuContainer: any;
+
   public availableMenuItems: NodeMenuItem[] = [
     {
       name: 'New tag',
@@ -52,7 +54,7 @@ export class NodeMenuComponent implements OnInit, OnDestroy {
 
   public ngOnInit(): void {
     this.disposersForGlobalListeners.push(this.renderer.listenGlobal('document', 'keyup', this.closeMenu.bind(this)));
-    this.disposersForGlobalListeners.push(this.renderer.listenGlobal('document', 'click', this.closeMenu.bind(this)));
+    this.disposersForGlobalListeners.push(this.renderer.listenGlobal('document', 'mousedown', this.closeMenu.bind(this)));
   }
 
   public ngOnDestroy(): void {
@@ -62,12 +64,16 @@ export class NodeMenuComponent implements OnInit, OnDestroy {
   public onMenuItemSelected(e: MouseEvent, selectedMenuItem: NodeMenuItem): void {
     if (isLeftButtonClicked(e)) {
       this.menuItemSelected.emit({nodeMenuItemAction: selectedMenuItem.action});
+      this.nodeMenuService.fireMenuEvent(e.target as HTMLElement, NodeMenuAction.Close);
     }
   }
 
   private closeMenu(e: MouseEvent | KeyboardEvent): void {
     const mouseClicked = e instanceof MouseEvent;
-    if (mouseClicked || isEscapePressed(e as KeyboardEvent)) {
+    // Check if the click is fired on an element inside a menu
+    const containingTarget = (this.menuContainer.nativeElement !== e.target && this.menuContainer.nativeElement.contains(e.target));
+
+    if (mouseClicked && !containingTarget || isEscapePressed(e as KeyboardEvent)) {
       this.nodeMenuService.fireMenuEvent(e.target as HTMLElement, NodeMenuAction.Close);
     }
   }
diff --git a/src/styles.css b/src/styles.css
index 1dbae59b..34997c95 100644
--- a/src/styles.css
+++ b/src/styles.css
@@ -103,6 +103,17 @@ tree-internal .tree .node-value:hover:after {
   width: 100%;
 }
 
+tree-internal .tree .node-left-menu {
+  display: inline-block;
+  height: 100%;
+  width: auto;
+}
+
+tree-internal .tree .node-left-menu:before {
+  content: '\2026';
+  color: #757575;
+}
+
 tree-internal .tree .node-selected:after {
   width: 100%;
 }
diff --git a/src/tree-internal.component.ts b/src/tree-internal.component.ts
index 979fc326..d161fa66 100644
--- a/src/tree-internal.component.ts
+++ b/src/tree-internal.component.ts
@@ -16,7 +16,7 @@ import { Observable } from 'rxjs';
     <li>
       <div class="value-container"
         [ngClass]="{rootless: isRootHidden()}"
-        (contextmenu)="showMenu($event)"
+        (contextmenu)="showRightMenu($event)"
         [nodeDraggable]="element"
         [tree]="tree">
 
@@ -32,9 +32,16 @@ import { Observable } from 'rxjs';
            *ngIf="shouldShowInputForTreeValue()"
            [nodeEditable]="tree.value"
            (valueChanged)="applyNewValue($event)"/>
+
+        <div class="node-left-menu" #leftMenuButton
+          *ngIf="tree.hasLeftMenu()" (click)="showLeftMenu($event)">
+        </div>
+        <node-menu *ngIf="tree.hasLeftMenu() && isLeftMenuVisible"
+          (menuItemSelected)="onMenuItemSelected($event)">
+        </node-menu>
       </div>
 
-      <node-menu *ngIf="isMenuVisible" (menuItemSelected)="onMenuItemSelected($event)"></node-menu>
+      <node-menu *ngIf="isRightMenuVisible" (menuItemSelected)="onMenuItemSelected($event)"></node-menu>
 
       <template [ngIf]="tree.isNodeExpanded()">
         <tree-internal *ngFor="let child of tree.childrenAsync | async" [tree]="child"></tree-internal>
@@ -51,7 +58,8 @@ export class TreeInternalComponent implements OnInit {
   public settings: Ng2TreeSettings;
 
   public isSelected: boolean = false;
-  public isMenuVisible: boolean = false;
+  public isRightMenuVisible: boolean = false;
+  public isLeftMenuVisible: boolean = false;
 
   public constructor(@Inject(NodeMenuService) private nodeMenuService: NodeMenuService,
                      @Inject(TreeService) private treeService: TreeService,
@@ -62,7 +70,10 @@ export class TreeInternalComponent implements OnInit {
     this.settings = this.settings || { rootIsVisible: true };
 
     this.nodeMenuService.hideMenuStream(this.element)
-      .subscribe(() => this.isMenuVisible = false);
+      .subscribe(() => {
+        this.isRightMenuVisible = false;
+        this.isLeftMenuVisible = false;
+      });
 
     this.treeService.unselectStream(this.tree)
       .subscribe(() => this.isSelected = false);
@@ -103,18 +114,32 @@ export class TreeInternalComponent implements OnInit {
     }
   }
 
-  public showMenu(e: MouseEvent): void {
-    if (this.tree.isStatic()) {
+  public showRightMenu(e: MouseEvent): void {
+    if (!this.tree.hasRightMenu()) {
       return;
     }
 
     if (EventUtils.isRightButtonClicked(e)) {
-      this.isMenuVisible = !this.isMenuVisible;
+      this.isRightMenuVisible = !this.isRightMenuVisible;
       this.nodeMenuService.hideMenuForAllNodesExcept(this.element);
     }
     e.preventDefault();
   }
 
+  public showLeftMenu(e: MouseEvent): void {
+    if (!this.tree.hasLeftMenu()) {
+      return;
+    }
+
+    if (EventUtils.isLeftButtonClicked(e)) {
+      this.isLeftMenuVisible = !this.isLeftMenuVisible;
+      this.nodeMenuService.hideMenuForAllNodesExcept(this.element);
+      if (this.isLeftMenuVisible) {
+        e.preventDefault();
+      }
+    }
+  }
+
   public onMenuItemSelected(e: NodeMenuItemSelectedEvent): void {
     switch (e.nodeMenuItemAction) {
       case NodeMenuItemAction.NewTag:
@@ -136,12 +161,14 @@ export class TreeInternalComponent implements OnInit {
 
   private onNewSelected(e: NodeMenuItemSelectedEvent): void {
     this.tree.createNode(e.nodeMenuItemAction === NodeMenuItemAction.NewFolder);
-    this.isMenuVisible = false;
+    this.isRightMenuVisible = false;
+    this.isLeftMenuVisible = false;
   }
 
   private onRenameSelected(): void {
     this.tree.markAsBeingRenamed();
-    this.isMenuVisible = false;
+    this.isRightMenuVisible = false;
+    this.isLeftMenuVisible = false;
   }
 
   private onRemoveSelected(): void {
diff --git a/src/tree.ts b/src/tree.ts
index eb0dd41e..b60ff5de 100644
--- a/src/tree.ts
+++ b/src/tree.ts
@@ -204,6 +204,22 @@ export class Tree {
     return _.get(this.node.settings, 'static', false);
   }
 
+  /**
+   * Check whether or not this tree has a left menu.
+   * @returns {boolean} A flag indicating whether or not this has a left menu.
+   */
+  public hasLeftMenu(): boolean {
+    return !_.get(this.node.settings, 'static', false) && _.get(this.node.settings, 'leftMenu', false);
+  }
+
+  /**
+   * Check whether or not this tree has a right menu.
+   * @returns {boolean} A flag indicating whether or not this has a right menu.
+   */
+  public hasRightMenu(): boolean {
+    return !_.get(this.node.settings, 'static', false) && _.get(this.node.settings, 'rightMenu', false);
+  }
+
   /**
    * Check whether this tree is "Leaf" or not.
    * @returns {boolean} A flag indicating whether or not this tree is a "Leaf".
diff --git a/src/tree.types.ts b/src/tree.types.ts
index c9f0b69d..e92144ea 100644
--- a/src/tree.types.ts
+++ b/src/tree.types.ts
@@ -25,6 +25,22 @@ export interface TreeModel {
 }
 
 export class TreeModelSettings {
+  /**
+   * "leftMenu" property when set to true makes left menu available.
+   * @name TreeModelSettings#leftMenu
+   * @type boolean
+   * @default false
+   */
+  public leftMenu?: boolean;
+
+  /**
+   * "rightMenu" property when set to true makes right menu available.
+   * @name TreeModelSettings#rightMenu
+   * @type boolean
+   * @default true
+   */
+  public rightMenu?: boolean;
+
   /**
    * "static" property when set to true makes it impossible to drag'n'drop tree or call a menu on it.
    * @name TreeModelSettings#static
@@ -34,7 +50,7 @@ export class TreeModelSettings {
   public static?: boolean;
 
   public static merge(sourceA: TreeModel, sourceB: TreeModel): TreeModelSettings {
-    return _.defaults({}, _.get(sourceA, 'settings'), _.get(sourceB, 'settings'), {static: false});
+    return _.defaults({}, _.get(sourceA, 'settings'), _.get(sourceB, 'settings'), {static: false, leftMenu: false, rightMenu: true});
   }
 }
 
diff --git a/test/left-menu.tree-internal.component.spec.ts b/test/left-menu.tree-internal.component.spec.ts
new file mode 100644
index 00000000..1ddbcb7d
--- /dev/null
+++ b/test/left-menu.tree-internal.component.spec.ts
@@ -0,0 +1,639 @@
+import { TestBed } from '@angular/core/testing';
+import { By } from '@angular/platform-browser';
+import { Component, ElementRef, DebugElement } from '@angular/core';
+import { TreeInternalComponent } from '../src/tree-internal.component';
+import { TreeComponent } from '../src/tree.component';
+import { TreeModel, Ng2TreeSettings } from '../src/tree.types';
+import { TreeService } from '../src/tree.service';
+import { NodeMenuService } from '../src/menu/node-menu.service';
+import { NodeMenuComponent } from '../src/menu/node-menu.component';
+import { NodeDraggableService } from '../src/draggable/node-draggable.service';
+import { NodeDraggableDirective } from '../src/draggable/node-draggable.directive';
+import { NodeEditableDirective } from '../src/editable/node-editable.directive';
+import { NodeMenuAction } from '../src/menu/menu.events';
+import * as EventUtils from '../src/utils/event.utils';
+import { CapturedNode } from '../src/draggable/captured-node';
+
+let fixture;
+let masterInternalTreeEl;
+let masterComponentInstance;
+let leftMenuInternalTreeEl;
+let leftMenuComponentInstance;
+let staticInternalTreeEl;
+let staticComponentInstance;
+let nodeMenuService;
+let nodeDraggableService;
+let treeService;
+
+const tree: TreeModel = {
+  value: 'Master',
+  settings: {
+    leftMenu: true,
+    rightMenu: false
+  },
+  children: [
+    {value: 'Servant#1'},
+    {value: 'Servant#2'}
+  ]
+};
+
+const tree2: TreeModel = {
+  value: 'Left Menu',
+  children: [
+    {value: 'Left Menu Not Set Child'},
+    {
+      value: 'Inactive',
+      settings: {
+        leftMenu: false
+      },
+      children: [
+        {value: 'Left Menu Inactive Child'}
+      ]
+    },
+    {
+      value: 'Active',
+      settings: {
+        leftMenu: true
+      },
+      children: [
+        {value: 'Left Menu Active Child'}
+      ]
+    },
+    {
+      value: 'Inactive With Active Children',
+      settings: {
+        leftMenu: false
+      },
+      children: [
+        {
+          value: 'Reactivate Lefft Menu',
+          settings: {
+            leftMenu: true
+          },
+          children: [
+            {value: 'Reactivated Left Menu Children'}
+          ]
+        }
+      ]
+    },
+  ]
+};
+
+const tree3: TreeModel = {
+  value: 'Face',
+  settings: {
+    'static': true,
+    leftMenu: true
+  },
+  children: [
+    {
+      value: 'Eyes',
+      settings: {
+        leftMenu: true
+      }
+    },
+    {
+      value: 'Retina',
+      settings: {
+        'static': false
+      },
+      children: [
+        {
+          value: 'Eyelash',
+          settings: {
+            leftMenu: true
+          }
+        },
+        {
+          value: 'Eyebow',
+          settings: {
+            leftMenu: false
+          },
+          children: []
+        }
+      ]
+    },
+    {value: 'Lips'}
+  ]
+};
+
+describe('LeftMenu-TreeInternalComponent', () => {
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      declarations: [TestComponent, TreeInternalComponent, TreeComponent, NodeEditableDirective, NodeMenuComponent, NodeDraggableDirective],
+      providers: [NodeMenuService, NodeDraggableService, TreeService]
+    });
+
+    fixture = TestBed.createComponent(TestComponent);
+
+    masterInternalTreeEl = fixture.debugElement.query(By.css('#master')).query(By.directive(TreeInternalComponent));
+    masterComponentInstance = masterInternalTreeEl.componentInstance;
+
+    leftMenuInternalTreeEl = fixture.debugElement.query(By.css('#left-menu')).query(By.directive(TreeInternalComponent));
+    leftMenuComponentInstance = leftMenuInternalTreeEl.componentInstance;
+
+    staticInternalTreeEl = fixture.debugElement.query(By.css('#static')).query(By.directive(TreeInternalComponent));
+    staticComponentInstance = leftMenuInternalTreeEl.componentInstance;
+
+    nodeMenuService = TestBed.get(NodeMenuService);
+    nodeDraggableService = TestBed.get(NodeDraggableService);
+    treeService = TestBed.get(TreeService);
+
+    fixture.detectChanges();
+  });
+
+  it('should be created by angular', () => {
+    expect(fixture).not.toBeNull();
+    expect(nodeMenuService).not.toBeNull();
+    expect(nodeDraggableService).not.toBeNull();
+    expect(treeService).not.toBeNull();
+  });
+
+  it('should hide left menu when appropriate event has occurred', () => {
+    spyOn(nodeMenuService, 'hideMenuForAllNodesExcept');
+
+    const event = jasmine.createSpyObj('e', ['preventDefault']);
+    event.button = EventUtils.MouseButtons.Left;
+
+    masterInternalTreeEl.query(By.css('.node-left-menu')).triggerEventHandler('click', event);
+
+    fixture.detectChanges();
+
+    expect(masterComponentInstance.isLeftMenuVisible).toEqual(true);
+    expect(event.preventDefault).toHaveBeenCalled();
+    expect(nodeMenuService.hideMenuForAllNodesExcept).toHaveBeenCalledTimes(1);
+    expect(nodeMenuService.hideMenuForAllNodesExcept).toHaveBeenCalledWith(masterComponentInstance.element);
+  });
+
+  it('shouldn`t have a left menu on node and it`s child by default', () => {
+    expect(leftMenuInternalTreeEl.query(By.css('.value-container')).queryAll(By.css('.node-left-menu')).length).toEqual(0);
+
+    const defaultChildEl = leftMenuInternalTreeEl.queryAll(By.directive(TreeInternalComponent))[0];
+    expect(defaultChildEl.query(By.css('.value-container')).queryAll(By.css('.node-left-menu')).length).toEqual(0);
+  });
+
+  it('shouldn`t have a left menu on node and it`s child when it has a settings - leftMenu to false', () => {
+    const inactiveLeftMenuEl = leftMenuInternalTreeEl.queryAll(By.directive(TreeInternalComponent))[1];
+    expect(inactiveLeftMenuEl.query(By.css('.value-container')).queryAll(By.css('.node-left-menu')).length).toEqual(0);
+
+    const inactiveLeftMenuChildEl = inactiveLeftMenuEl.queryAll(By.directive(TreeInternalComponent))[0];
+    expect(inactiveLeftMenuChildEl.query(By.css('.value-container')).queryAll(By.css('.node-left-menu')).length).toEqual(0);
+  });
+
+  it('should show left menu on node', () => {
+    const event = jasmine.createSpyObj('e', ['preventDefault']);
+    event.button = EventUtils.MouseButtons.Left;
+
+    const activeLeftMenuEl = leftMenuInternalTreeEl.queryAll(By.directive(TreeInternalComponent))[3];
+    activeLeftMenuEl.query(By.css('.value-container')).query(By.css('.node-left-menu')).triggerEventHandler('click', event);
+
+    fixture.detectChanges();
+
+    expect(activeLeftMenuEl.componentInstance.isLeftMenuVisible).toEqual(true);
+    const menus = activeLeftMenuEl.queryAll(By.css('.node-menu'));
+
+    expect(menus.length).toEqual(1);
+    expect(menus[0].queryAll(By.css('.node-menu-item')).length).toEqual(4);
+  });
+
+  it('should show left menu on node`s child, which has a setting leftMenu - true', () => {
+    const event = jasmine.createSpyObj('e', ['preventDefault']);
+    event.button = EventUtils.MouseButtons.Left;
+
+    const activeLeftMenuEl = leftMenuInternalTreeEl.queryAll(By.directive(TreeInternalComponent))[3];
+    const activeLeftMenuChildEl = activeLeftMenuEl.queryAll(By.directive(TreeInternalComponent))[0];
+
+    activeLeftMenuEl.query(By.css('.value-container')).query(By.css('.node-left-menu')).triggerEventHandler('click', event);
+
+    fixture.detectChanges();
+
+    expect(activeLeftMenuEl.componentInstance.isLeftMenuVisible).toEqual(true);
+    const menus = activeLeftMenuEl.queryAll(By.css('.node-menu'));
+
+    expect(menus.length).toEqual(1);
+    expect(menus[0].queryAll(By.css('.node-menu-item')).length).toEqual(4);
+  });
+
+  it('should remove node by click on appropriate menu item', () => {
+    const event = jasmine.createSpyObj('e', ['preventDefault']);
+    event.button = EventUtils.MouseButtons.Left;
+
+    const servantEls = masterInternalTreeEl.queryAll(By.directive(TreeInternalComponent));
+    const servant1El = servantEls[0];
+
+    servant1El.query(By.css('.value-container')).query(By.css('.node-left-menu')).triggerEventHandler('click', event);
+
+    fixture.detectChanges();
+
+    expect(servant1El.componentInstance.isLeftMenuVisible).toEqual(true);
+    const menu = servant1El.query(By.css('.node-menu'));
+
+    const menuItemRemove: DebugElement = menu.query(By.css('.remove')).parent;
+
+    const eventRemove = {button: EventUtils.MouseButtons.Left};
+    menuItemRemove.triggerEventHandler('click', eventRemove);
+
+    fixture.detectChanges();
+
+    const remainedSevantEls = masterInternalTreeEl.queryAll(By.directive(TreeInternalComponent));
+    expect(remainedSevantEls.length).toEqual(1);
+    expect(remainedSevantEls[0].componentInstance.tree.value).toEqual('Servant#2');
+  });
+
+  it('should hide menu on click outside of menu', () => {
+    const event = jasmine.createSpyObj('e', ['preventDefault']);
+    event.button = EventUtils.MouseButtons.Left;
+
+    const servantEls = masterInternalTreeEl.queryAll(By.directive(TreeInternalComponent));
+    const servant1El = servantEls[0];
+
+    servant1El.query(By.css('.value-container')).query(By.css('.node-left-menu')).triggerEventHandler('click', event);
+
+    fixture.detectChanges();
+
+    expect(servant1El.componentInstance.isLeftMenuVisible).toEqual(true);
+    expect(servant1El.query(By.css('.node-menu'))).toBeDefined();
+
+    nodeMenuService.fireMenuEvent(null, NodeMenuAction.Close);
+
+    fixture.detectChanges();
+
+    expect(servant1El.componentInstance.isLeftMenuVisible).toEqual(false);
+    expect(servant1El.query(By.css('.node-menu'))).toBeNull();
+  });
+
+  it('should rename node on enter', () => {
+    const event = jasmine.createSpyObj('e', ['preventDefault']);
+    event.button = EventUtils.MouseButtons.Left;
+
+    masterInternalTreeEl.query(By.css('.value-container')).query(By.css('.node-left-menu')).triggerEventHandler('click', event);
+
+    fixture.detectChanges();
+
+    expect(masterInternalTreeEl.componentInstance.isLeftMenuVisible).toEqual(true);
+    const menu = masterInternalTreeEl.query(By.css('.node-menu'));
+
+    const menuItemRename: DebugElement = menu.query(By.css('.rename')).parent;
+
+    const eventRename = {button: EventUtils.MouseButtons.Left};
+    menuItemRename.triggerEventHandler('click', eventRename);
+
+    fixture.detectChanges();
+
+    const inputRename = masterInternalTreeEl.query(By.css('input.node-value'));
+    expect(inputRename).toBeDefined();
+    inputRename.triggerEventHandler('keyup.enter', {target: {value: 'bla'}});
+
+    fixture.detectChanges();
+
+    expect(masterComponentInstance.tree.value).toEqual('bla');
+  });
+
+  it('should rename node on blur', () => {
+    const event = jasmine.createSpyObj('e', ['preventDefault']);
+    event.button = EventUtils.MouseButtons.Left;
+
+    masterInternalTreeEl.query(By.css('.value-container')).query(By.css('.node-left-menu')).triggerEventHandler('click', event);
+
+    fixture.detectChanges();
+
+    expect(masterInternalTreeEl.componentInstance.isLeftMenuVisible).toEqual(true);
+    const menu = masterInternalTreeEl.query(By.css('.node-menu'));
+
+    const menuItemRename: DebugElement = menu.query(By.css('.rename')).parent;
+
+    const eventRename = {button: EventUtils.MouseButtons.Left};
+    menuItemRename.triggerEventHandler('click', eventRename);
+
+    fixture.detectChanges();
+
+    const inputRename = masterInternalTreeEl.query(By.css('input.node-value'));
+    expect(inputRename).toBeDefined();
+    inputRename.triggerEventHandler('blur', {target: {value: 'bla'}});
+
+    fixture.detectChanges();
+
+    expect(masterComponentInstance.tree.value).toEqual('bla');
+  });
+
+  it('should cancel renaming node on escape pressed', () => {
+    const event = jasmine.createSpyObj('e', ['preventDefault']);
+    event.button = EventUtils.MouseButtons.Left;
+
+    masterInternalTreeEl.query(By.css('.value-container')).query(By.css('.node-left-menu')).triggerEventHandler('click', event);
+
+    fixture.detectChanges();
+
+    expect(masterInternalTreeEl.componentInstance.isLeftMenuVisible).toEqual(true);
+    const menu = masterInternalTreeEl.query(By.css('.node-menu'));
+
+    const menuItemRename: DebugElement = menu.query(By.css('.rename')).parent;
+
+    const eventRename = {button: EventUtils.MouseButtons.Left};
+    menuItemRename.triggerEventHandler('click', eventRename);
+
+    fixture.detectChanges();
+
+    const inputRename = masterInternalTreeEl.query(By.css('input.node-value'));
+    expect(inputRename).toBeDefined();
+    inputRename.nativeElement.value = '121212';
+    inputRename.triggerEventHandler('keyup.esc', {target: {value: 'bla'}});
+
+    fixture.detectChanges();
+
+    expect(masterComponentInstance.tree.value).toEqual('Master');
+  });
+
+  it('should not rename node on empty input', () => {
+    const event = jasmine.createSpyObj('e', ['preventDefault']);
+    event.button = EventUtils.MouseButtons.Left;
+
+    masterInternalTreeEl.query(By.css('.value-container')).query(By.css('.node-left-menu')).triggerEventHandler('click', event);
+
+    fixture.detectChanges();
+
+    expect(masterInternalTreeEl.componentInstance.isLeftMenuVisible).toEqual(true);
+    const menu = masterInternalTreeEl.query(By.css('.node-menu'));
+
+    const menuItemRename: DebugElement = menu.query(By.css('.rename')).parent;
+
+    const eventRename = {button: EventUtils.MouseButtons.Left};
+    menuItemRename.triggerEventHandler('click', eventRename);
+
+    fixture.detectChanges();
+
+    const inputRename = masterInternalTreeEl.query(By.css('input.node-value'));
+    expect(inputRename).toBeDefined();
+    inputRename.triggerEventHandler('blur', {target: {value: ''}});
+
+    fixture.detectChanges();
+
+    expect(masterComponentInstance.tree.value).toEqual('Master');
+  });
+
+  it('should create a leaf child when NewTag operation activated on a branch node', () => {
+    const event = jasmine.createSpyObj('e', ['preventDefault']);
+    event.button = EventUtils.MouseButtons.Left;
+
+    masterInternalTreeEl.query(By.css('.value-container')).query(By.css('.node-left-menu')).triggerEventHandler('click', event);
+
+    fixture.detectChanges();
+
+    expect(masterInternalTreeEl.componentInstance.isLeftMenuVisible).toEqual(true);
+    const menu = masterInternalTreeEl.query(By.css('.node-menu'));
+
+    const menuNewTag: DebugElement = menu.query(By.css('.new-tag')).parent;
+
+    const eventRename = {button: EventUtils.MouseButtons.Left};
+    menuNewTag.triggerEventHandler('click', eventRename);
+
+    fixture.detectChanges();
+
+    const inputRename = masterInternalTreeEl.query(By.css('input.node-value'));
+    expect(inputRename).toBeDefined();
+    inputRename.triggerEventHandler('keyup.enter', {target: {value: 'bla'}});
+
+    fixture.detectChanges();
+
+    expect(masterComponentInstance.tree.children.length).toEqual(3);
+    expect(masterComponentInstance.tree.children[2].value).toEqual('bla');
+    expect(masterInternalTreeEl.queryAll(By.directive(TreeInternalComponent))[2].nativeElement.querySelector('.node-value').innerText).toEqual('bla');
+  });
+
+  it('should create a sibling leaf when NewTag operation was activated on a node that is leaf', () => {
+    const event = jasmine.createSpyObj('e', ['preventDefault']);
+    event.button = EventUtils.MouseButtons.Left;
+
+    const servant1El = masterInternalTreeEl.query(By.directive(TreeInternalComponent));
+
+    servant1El.query(By.css('.value-container')).query(By.css('.node-left-menu')).triggerEventHandler('click', event);
+
+    fixture.detectChanges();
+
+    expect(servant1El.componentInstance.isLeftMenuVisible).toEqual(true);
+    const menu = servant1El.query(By.css('.node-menu'));
+
+    const menuNewTag: DebugElement = menu.query(By.css('.new-tag')).parent;
+
+    const eventRename = {button: EventUtils.MouseButtons.Left};
+    menuNewTag.triggerEventHandler('click', eventRename);
+
+    fixture.detectChanges();
+
+    const inputRename = masterInternalTreeEl.query(By.css('input.node-value'));
+    expect(inputRename).toBeTruthy();
+    inputRename.triggerEventHandler('keyup.enter', {target: {value: 'bla'}});
+
+    fixture.detectChanges();
+
+    expect(masterComponentInstance.tree.children.length).toEqual(3);
+    expect(masterComponentInstance.tree.children[2].value).toEqual('bla');
+    expect(masterInternalTreeEl.queryAll(By.directive(TreeInternalComponent))[2].nativeElement.querySelector('.node-value').innerText).toEqual('bla');
+  });
+
+  it('should not create a node with empty value', () => {
+    const event = jasmine.createSpyObj('e', ['preventDefault']);
+    event.button = EventUtils.MouseButtons.Left;
+
+    masterInternalTreeEl.query(By.css('.value-container')).query(By.css('.node-left-menu')).triggerEventHandler('click', event);
+
+    fixture.detectChanges();
+
+    expect(masterInternalTreeEl.componentInstance.isLeftMenuVisible).toEqual(true);
+    const menu = masterInternalTreeEl.query(By.css('.node-menu'));
+
+    const menuNewTag: DebugElement = menu.query(By.css('.new-tag')).parent;
+
+    const eventRename = {button: EventUtils.MouseButtons.Left};
+    menuNewTag.triggerEventHandler('click', eventRename);
+
+    fixture.detectChanges();
+
+    const inputRename = masterInternalTreeEl.query(By.css('input.node-value'));
+    expect(inputRename).toBeDefined();
+    inputRename.triggerEventHandler('keyup.enter', {target: {value: '\r\n\t '}});
+
+    fixture.detectChanges();
+
+    expect(masterComponentInstance.tree.children.length).toEqual(2);
+    expect(masterComponentInstance.tree.children[0].value).toEqual('Servant#1');
+    expect(masterComponentInstance.tree.children[1].value).toEqual('Servant#2');
+
+    const servantEls = masterInternalTreeEl.queryAll(By.directive(TreeInternalComponent));
+    expect(servantEls.length).toEqual(2);
+    expect(servantEls[0].nativeElement.querySelector('.node-value').innerText).toEqual('Servant#1');
+    expect(servantEls[1].nativeElement.querySelector('.node-value').innerText).toEqual('Servant#2');
+  });
+
+  it('should create a branch node when NewFolder operation activated', () => {
+    const event = jasmine.createSpyObj('e', ['preventDefault']);
+    event.button = EventUtils.MouseButtons.Left;
+
+    masterInternalTreeEl.query(By.css('.value-container')).query(By.css('.node-left-menu')).triggerEventHandler('click', event);
+
+    fixture.detectChanges();
+
+    expect(masterInternalTreeEl.componentInstance.isLeftMenuVisible).toEqual(true);
+    const menu = masterInternalTreeEl.query(By.css('.node-menu'));
+
+    const menuNewTag: DebugElement = menu.query(By.css('.new-folder')).parent;
+
+    const eventRename = {button: EventUtils.MouseButtons.Left};
+    menuNewTag.triggerEventHandler('click', eventRename);
+
+    fixture.detectChanges();
+
+    const inputRename = masterInternalTreeEl.query(By.css('input.node-value'));
+    expect(inputRename).toBeDefined();
+    inputRename.triggerEventHandler('keyup.enter', {target: {value: 'Branch'}});
+
+    fixture.detectChanges();
+
+    expect(masterComponentInstance.tree.children.length).toEqual(3);
+    expect(masterComponentInstance.tree.children[2].value).toEqual('Branch');
+    expect(masterComponentInstance.tree.children[2].isBranch()).toEqual(true);
+    expect(masterComponentInstance.tree.children[2].children).toBeDefined();
+    expect(masterComponentInstance.tree.children[2].children.length).toEqual(0);
+    expect(masterInternalTreeEl.queryAll(By.directive(TreeInternalComponent))[2].nativeElement.querySelector('.node-value').innerText).toEqual('Branch');
+  });
+
+  describe('Static Tree', () => {
+    it('should not show left menu', () => {
+      expect(staticInternalTreeEl.query(By.css('.value-container')).queryAll(By.css('.node-left-menu')).length).toEqual(0);
+
+      const childEl = staticInternalTreeEl.queryAll(By.directive(TreeInternalComponent))[0];
+      expect(childEl.query(By.css('.value-container')).queryAll(By.css('.node-left-menu')).length).toEqual(0);
+
+      const event = jasmine.createSpyObj('e', ['preventDefault']);
+      event.button = EventUtils.MouseButtons.Left;
+
+      staticComponentInstance.showLeftMenu(event);
+
+      fixture.detectChanges();
+
+      expect(staticComponentInstance.isLeftMenuVisible).toEqual(false);
+      expect(staticInternalTreeEl.query(By.css('.node-menu'))).toEqual(null);
+    });
+
+    it('should not show left menu when settings leftMenu is false', () => {
+      const internalTreeChildren = staticInternalTreeEl.queryAll(By.directive(TreeInternalComponent));
+      const eyebowEl = internalTreeChildren[3];
+
+      expect(eyebowEl.componentInstance.tree.value).toEqual('Eyebow');
+      expect(eyebowEl.componentInstance.tree.positionInParent).toEqual(1);
+
+      expect(eyebowEl.query(By.css('.value-container')).queryAll(By.css('.node-left-menu')).length).toEqual(0);
+
+      const event = jasmine.createSpyObj('e', ['preventDefault']);
+      event.button = EventUtils.MouseButtons.Left;
+
+      staticComponentInstance.showLeftMenu(event);
+
+      fixture.detectChanges();
+
+      expect(eyebowEl.componentInstance.isLeftMenuVisible).toEqual(false);
+      expect(eyebowEl.query(By.css('.node-menu'))).toEqual(null);
+    });
+
+    it('should allow to override static option for it\'s children', () => {
+      const event = jasmine.createSpyObj('e', ['preventDefault']);
+      event.button = EventUtils.MouseButtons.Left;
+
+      const childEl = staticInternalTreeEl.queryAll(By.directive(TreeInternalComponent))[1];
+      childEl.query(By.css('.value-container')).query(By.css('.node-left-menu')).triggerEventHandler('click', event);
+
+      fixture.detectChanges();
+
+      expect(childEl.componentInstance.tree.value).toEqual('Retina');
+      expect(childEl.componentInstance.isLeftMenuVisible).toEqual(true);
+      expect(childEl.query(By.css('.node-menu'))).toBeTruthy();
+    });
+
+    it('should not be draggable', () => {
+      const internalTreeChildren = staticInternalTreeEl.queryAll(By.directive(TreeInternalComponent));
+      const eyesEl = internalTreeChildren[0];
+      const lipsEl = internalTreeChildren[4];
+
+      expect(eyesEl.componentInstance.tree.value).toEqual('Eyes');
+      expect(eyesEl.componentInstance.tree.positionInParent).toEqual(0);
+
+      expect(lipsEl.componentInstance.tree.value).toEqual('Lips');
+      expect(lipsEl.componentInstance.tree.positionInParent).toEqual(2);
+
+      expect(staticInternalTreeEl.componentInstance.tree.children[0].value).toEqual('Eyes');
+      expect(staticInternalTreeEl.componentInstance.tree.children[2].value).toEqual('Lips');
+
+      const capturedNode = new CapturedNode(eyesEl.componentInstance.element, eyesEl.componentInstance.tree);
+      nodeDraggableService.fireNodeDragged(capturedNode, lipsEl.componentInstance.element);
+
+      fixture.detectChanges();
+
+      expect(eyesEl.componentInstance.tree.positionInParent).toEqual(0);
+      expect(lipsEl.componentInstance.tree.positionInParent).toEqual(2);
+
+      expect(staticInternalTreeEl.componentInstance.tree.children[0].value).toEqual('Eyes');
+      expect(staticInternalTreeEl.componentInstance.tree.children[2].value).toEqual('Lips');
+
+      const nativeElement = staticInternalTreeEl.nativeElement;
+      const nodeValues = nativeElement.querySelectorAll('.node-value');
+      expect(nodeValues[0].innerText).toEqual('Face');
+      expect(nodeValues[1].innerText).toEqual('Eyes');
+      expect(nodeValues[2].innerText).toEqual('Retina');
+      expect(nodeValues[3].innerText).toEqual('Eyelash');
+      expect(nodeValues[4].innerText).toEqual('Eyebow');
+      expect(nodeValues[5].innerText).toEqual('Lips');
+    });
+
+    it('should allow to drag and drop not static elements in a static parent', () => {
+      const internalTreeChildren = staticInternalTreeEl.queryAll(By.directive(TreeInternalComponent));
+      const eyelashEl = internalTreeChildren[2];
+      const eyebowEl = internalTreeChildren[3];
+
+      expect(eyelashEl.componentInstance.tree.value).toEqual('Eyelash');
+      expect(eyelashEl.componentInstance.tree.positionInParent).toEqual(0);
+
+      expect(eyebowEl.componentInstance.tree.value).toEqual('Eyebow');
+      expect(eyebowEl.componentInstance.tree.positionInParent).toEqual(1);
+
+      expect(staticInternalTreeEl.componentInstance.tree.children[1].children[0].value).toEqual('Eyelash');
+      expect(staticInternalTreeEl.componentInstance.tree.children[1].children[1].value).toEqual('Eyebow');
+
+      const capturedNode = new CapturedNode(eyelashEl.componentInstance.element, eyelashEl.componentInstance.tree);
+      nodeDraggableService.fireNodeDragged(capturedNode, eyebowEl.componentInstance.element);
+
+      fixture.detectChanges();
+
+      expect(eyelashEl.componentInstance.tree.positionInParent).toEqual(1);
+      expect(eyebowEl.componentInstance.tree.positionInParent).toEqual(0);
+
+      expect(staticInternalTreeEl.componentInstance.tree.children[1].children[0].value).toEqual('Eyebow');
+      expect(staticInternalTreeEl.componentInstance.tree.children[1].children[1].value).toEqual('Eyelash');
+
+      const nativeElement = staticInternalTreeEl.nativeElement;
+      const nodeValues = nativeElement.querySelectorAll('.node-value');
+
+      expect(nodeValues[0].innerText).toEqual('Face');
+      expect(nodeValues[1].innerText).toEqual('Eyes');
+      expect(nodeValues[2].innerText).toEqual('Retina');
+      expect(nodeValues[3].innerText).toEqual('Eyebow');
+      expect(nodeValues[4].innerText).toEqual('Eyelash');
+      expect(nodeValues[5].innerText).toEqual('Lips');
+    });
+  });
+});
+
+@Component({
+  template: `
+  <div><tree id="master" [tree]="tree"></tree></div>
+  <div><tree id="left-menu" [tree]="tree2"></tree></div>
+  <div><tree id="static" [tree]="tree3"></tree></div>
+`
+})
+class TestComponent {
+  public tree: TreeModel = tree;
+  public tree2: TreeModel = tree2;
+  public tree3: TreeModel = tree3;
+
+  public constructor(public treeHolder: ElementRef) {
+  }
+}
diff --git a/test/menu/node-menu.component.spec.ts b/test/menu/node-menu.component.spec.ts
index d8fecf34..0cb512ce 100644
--- a/test/menu/node-menu.component.spec.ts
+++ b/test/menu/node-menu.component.spec.ts
@@ -115,7 +115,7 @@ describe('NodeMenuComponent', () => {
     spyOn(nodeMenuService.nodeMenuEvents$, 'next');
 
     const event = document.createEvent("MouseEvents");
-    event.initMouseEvent('click', true, true, window, 0, 0, 0, 0, 0, false, false, false, false, 0, null);
+    event.initMouseEvent('mousedown', true, true, window, 0, 0, 0, 0, 0, false, false, false, false, 0, null);
     document.dispatchEvent(event);
 
     const expectedNodeMenuEvent: NodeMenuEvent = {
diff --git a/test/right-menu.tree-internal.component.spec.ts b/test/right-menu.tree-internal.component.spec.ts
new file mode 100644
index 00000000..bd85069a
--- /dev/null
+++ b/test/right-menu.tree-internal.component.spec.ts
@@ -0,0 +1,636 @@
+import { TestBed } from '@angular/core/testing';
+import { By } from '@angular/platform-browser';
+import { Component, ElementRef, DebugElement } from '@angular/core';
+import { TreeInternalComponent } from '../src/tree-internal.component';
+import { TreeComponent } from '../src/tree.component';
+import { TreeModel, Ng2TreeSettings } from '../src/tree.types';
+import { TreeService } from '../src/tree.service';
+import { NodeMenuService } from '../src/menu/node-menu.service';
+import { NodeMenuComponent } from '../src/menu/node-menu.component';
+import { NodeDraggableService } from '../src/draggable/node-draggable.service';
+import { NodeDraggableDirective } from '../src/draggable/node-draggable.directive';
+import { NodeEditableDirective } from '../src/editable/node-editable.directive';
+import { NodeMenuAction } from '../src/menu/menu.events';
+import * as EventUtils from '../src/utils/event.utils';
+import { CapturedNode } from '../src/draggable/captured-node';
+
+let fixture;
+let masterInternalTreeEl;
+let masterComponentInstance;
+let rightMenuInternalTreeEl;
+let rightMenuComponentInstance;
+let staticInternalTreeEl;
+let staticComponentInstance;
+let nodeMenuService;
+let nodeDraggableService;
+let treeService;
+
+const tree: TreeModel = {
+  value: 'Master',
+  children: [
+    {value: 'Servant#1'},
+    {value: 'Servant#2'}
+  ]
+};
+
+const tree2: TreeModel = {
+  value: 'Right Menu',
+  children: [
+    {value: 'Right Menu Not Set Child'},
+    {
+      value: 'Inactive',
+      settings: {
+        rightMenu: false
+      },
+      children: [
+        {value: 'Right Menu Inactive Child'}
+      ]
+    },
+    {
+      value: 'Active',
+      settings: {
+        rightMenu: true
+      },
+      children: [
+        {value: 'Right Menu Active Child'}
+      ]
+    },
+    {
+      value: 'Inactive With Active Children',
+      settings: {
+        rightMenu: false
+      },
+      children: [
+        {
+          value: 'Reactivate Right Menu',
+          settings: {
+            rightMenu: true
+          },
+          children: [
+            {value: 'Reactivated Right Menu Children'}
+          ]
+        }
+      ]
+    },
+  ]
+};
+
+const tree3: TreeModel = {
+  value: 'Face',
+  settings: {
+    'static': true,
+    rightMenu: true
+  },
+  children: [
+    {
+      value: 'Eyes',
+      settings: {
+        rightMenu: true
+      }
+    },
+    {
+      value: 'Retina',
+      settings: {
+        'static': false
+      },
+      children: [
+        {
+          value: 'Eyelash',
+          settings: {
+            rightMenu: true
+          }
+        },
+        {
+          value: 'Eyebow',
+          settings: {
+            rightMenu: false
+          },
+          children: []
+        }
+      ]
+    },
+    {value: 'Lips'}
+  ]
+};
+
+describe('RightMenu-TreeInternalComponent', () => {
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      declarations: [TestComponent, TreeInternalComponent, TreeComponent, NodeEditableDirective, NodeMenuComponent, NodeDraggableDirective],
+      providers: [NodeMenuService, NodeDraggableService, TreeService]
+    });
+
+    fixture = TestBed.createComponent(TestComponent);
+
+    masterInternalTreeEl = fixture.debugElement.query(By.css('#master')).query(By.directive(TreeInternalComponent));
+    masterComponentInstance = masterInternalTreeEl.componentInstance;
+
+    rightMenuInternalTreeEl = fixture.debugElement.query(By.css('#right-menu')).query(By.directive(TreeInternalComponent));
+    rightMenuComponentInstance = rightMenuInternalTreeEl.componentInstance;
+
+    staticInternalTreeEl = fixture.debugElement.query(By.css('#static')).query(By.directive(TreeInternalComponent));
+    staticComponentInstance = staticInternalTreeEl.componentInstance;
+
+    nodeMenuService = TestBed.get(NodeMenuService);
+    nodeDraggableService = TestBed.get(NodeDraggableService);
+    treeService = TestBed.get(TreeService);
+
+    fixture.detectChanges();
+  });
+
+  it('should be created by angular', () => {
+    expect(fixture).not.toBeNull();
+    expect(nodeMenuService).not.toBeNull();
+    expect(nodeDraggableService).not.toBeNull();
+    expect(treeService).not.toBeNull();
+  });
+
+  it('should hide right menu when appropriate event has occurred', () => {
+    spyOn(nodeMenuService, 'hideMenuForAllNodesExcept');
+
+    const event = jasmine.createSpyObj('e', ['preventDefault']);
+    event.button = EventUtils.MouseButtons.Right;
+
+    masterInternalTreeEl.query(By.css('.value-container')).triggerEventHandler('contextmenu', event);
+
+    fixture.detectChanges();
+
+    expect(masterComponentInstance.isRightMenuVisible).toEqual(true);
+    expect(event.preventDefault).toHaveBeenCalled();
+    expect(nodeMenuService.hideMenuForAllNodesExcept).toHaveBeenCalledTimes(1);
+    expect(nodeMenuService.hideMenuForAllNodesExcept).toHaveBeenCalledWith(masterComponentInstance.element);
+  });
+
+  it('should show right menu on node by default', () => {
+    const event = jasmine.createSpyObj('e', ['preventDefault']);
+    event.button = EventUtils.MouseButtons.Right;
+
+    rightMenuInternalTreeEl.query(By.css('.value-container')).triggerEventHandler('contextmenu', event);
+
+    fixture.detectChanges();
+
+    expect(rightMenuComponentInstance.isRightMenuVisible).toEqual(true);
+    const menus = rightMenuInternalTreeEl.queryAll(By.css('.node-menu'));
+
+    expect(menus.length).toEqual(1);
+    expect(menus[0].queryAll(By.css('.node-menu-item')).length).toEqual(4);
+  });
+
+  it('should show right menu on node`s child, which has no special configuration', () => {
+    const event = jasmine.createSpyObj('e', ['preventDefault']);
+    event.button = EventUtils.MouseButtons.Right;
+
+    const defaultChild = rightMenuInternalTreeEl.queryAll(By.directive(TreeInternalComponent))[0];
+
+    defaultChild.query(By.css('.value-container')).triggerEventHandler('contextmenu', event);
+
+    fixture.detectChanges();
+
+    expect(defaultChild.componentInstance.isRightMenuVisible).toEqual(true);
+    const menus = defaultChild.queryAll(By.css('.node-menu'));
+
+    expect(menus.length).toEqual(1);
+    expect(menus[0].queryAll(By.css('.node-menu-item')).length).toEqual(4);
+  });
+
+  it('shouldn`t show right menu on node and it`s children, which has setting rightMenu - false', () => {
+    const event = jasmine.createSpyObj('e', ['preventDefault']);
+    event.button = EventUtils.MouseButtons.Right;
+
+    const inactiveChild = rightMenuInternalTreeEl.queryAll(By.directive(TreeInternalComponent))[1];
+
+    inactiveChild.query(By.css('.value-container')).triggerEventHandler('contextmenu', event);
+
+    fixture.detectChanges();
+
+    expect(inactiveChild.componentInstance.isRightMenuVisible).toEqual(false);
+    expect(inactiveChild.query(By.css('.node-menu'))).toEqual(null);
+
+    const childEl = inactiveChild.query(By.directive(TreeInternalComponent));
+    expect(childEl.componentInstance.isRightMenuVisible).toEqual(false);
+    expect(childEl.query(By.css('.node-menu'))).toEqual(null);
+  });
+
+  it('should remove node by click on appropriate menu item', () => {
+    const event = jasmine.createSpyObj('e', ['preventDefault']);
+    event.button = EventUtils.MouseButtons.Right;
+
+    const servantEls = masterInternalTreeEl.queryAll(By.directive(TreeInternalComponent));
+    const servant1El = servantEls[0];
+
+    servant1El.query(By.css('.value-container')).triggerEventHandler('contextmenu', event);
+
+    fixture.detectChanges();
+
+    expect(servant1El.componentInstance.isRightMenuVisible).toEqual(true);
+    const menu = servant1El.query(By.css('.node-menu'));
+
+    const menuItemRemove: DebugElement = menu.query(By.css('.remove')).parent;
+
+    const eventRemove = {button: EventUtils.MouseButtons.Left};
+    menuItemRemove.triggerEventHandler('click', eventRemove);
+
+    fixture.detectChanges();
+
+    const remainedSevantEls = masterInternalTreeEl.queryAll(By.directive(TreeInternalComponent));
+    expect(remainedSevantEls.length).toEqual(1);
+    expect(remainedSevantEls[0].componentInstance.tree.value).toEqual('Servant#2');
+  });
+
+  it('should hide menu on click outside of menu', () => {
+    const event = jasmine.createSpyObj('e', ['preventDefault']);
+    event.button = EventUtils.MouseButtons.Right;
+
+    const servantEls = masterInternalTreeEl.queryAll(By.directive(TreeInternalComponent));
+    const servant1El = servantEls[0];
+
+    servant1El.query(By.css('.value-container')).triggerEventHandler('contextmenu', event);
+
+    fixture.detectChanges();
+
+    expect(servant1El.componentInstance.isRightMenuVisible).toEqual(true);
+    expect(servant1El.query(By.css('.node-menu'))).toBeDefined();
+
+    nodeMenuService.fireMenuEvent(null, NodeMenuAction.Close);
+
+    fixture.detectChanges();
+
+    expect(servant1El.componentInstance.isRightMenuVisible).toEqual(false);
+    expect(servant1El.query(By.css('.node-menu'))).toBeNull();
+  });
+
+  it('should rename node on enter', () => {
+    const event = jasmine.createSpyObj('e', ['preventDefault']);
+    event.button = EventUtils.MouseButtons.Right;
+
+    masterInternalTreeEl.query(By.css('.value-container')).triggerEventHandler('contextmenu', event);
+
+    fixture.detectChanges();
+
+    expect(masterInternalTreeEl.componentInstance.isRightMenuVisible).toEqual(true);
+    const menu = masterInternalTreeEl.query(By.css('.node-menu'));
+
+    const menuItemRename: DebugElement = menu.query(By.css('.rename')).parent;
+
+    const eventRename = {button: EventUtils.MouseButtons.Left};
+    menuItemRename.triggerEventHandler('click', eventRename);
+
+    fixture.detectChanges();
+
+    const inputRename = masterInternalTreeEl.query(By.css('input.node-value'));
+    expect(inputRename).toBeDefined();
+    inputRename.triggerEventHandler('keyup.enter', {target: {value: 'bla'}});
+
+    fixture.detectChanges();
+
+    expect(masterComponentInstance.tree.value).toEqual('bla');
+  });
+
+  it('should rename node on blur', () => {
+    const event = jasmine.createSpyObj('e', ['preventDefault']);
+    event.button = EventUtils.MouseButtons.Right;
+
+    masterInternalTreeEl.query(By.css('.value-container')).triggerEventHandler('contextmenu', event);
+
+    fixture.detectChanges();
+
+    expect(masterInternalTreeEl.componentInstance.isRightMenuVisible).toEqual(true);
+    const menu = masterInternalTreeEl.query(By.css('.node-menu'));
+
+    const menuItemRename: DebugElement = menu.query(By.css('.rename')).parent;
+
+    const eventRename = {button: EventUtils.MouseButtons.Left};
+    menuItemRename.triggerEventHandler('click', eventRename);
+
+    fixture.detectChanges();
+
+    const inputRename = masterInternalTreeEl.query(By.css('input.node-value'));
+    expect(inputRename).toBeDefined();
+    inputRename.triggerEventHandler('blur', {target: {value: 'bla'}});
+
+    fixture.detectChanges();
+
+    expect(masterComponentInstance.tree.value).toEqual('bla');
+  });
+
+  it('should cancel renaming node on escape pressed', () => {
+    const event = jasmine.createSpyObj('e', ['preventDefault']);
+    event.button = EventUtils.MouseButtons.Right;
+
+    masterInternalTreeEl.query(By.css('.value-container')).triggerEventHandler('contextmenu', event);
+
+    fixture.detectChanges();
+
+    expect(masterInternalTreeEl.componentInstance.isRightMenuVisible).toEqual(true);
+    const menu = masterInternalTreeEl.query(By.css('.node-menu'));
+
+    const menuItemRename: DebugElement = menu.query(By.css('.rename')).parent;
+
+    const eventRename = {button: EventUtils.MouseButtons.Left};
+    menuItemRename.triggerEventHandler('click', eventRename);
+
+    fixture.detectChanges();
+
+    const inputRename = masterInternalTreeEl.query(By.css('input.node-value'));
+    expect(inputRename).toBeDefined();
+    inputRename.nativeElement.value = '121212';
+    inputRename.triggerEventHandler('keyup.esc', {target: {value: 'bla'}});
+
+    fixture.detectChanges();
+
+    expect(masterComponentInstance.tree.value).toEqual('Master');
+  });
+
+  it('should not rename node on empty input', () => {
+    const event = jasmine.createSpyObj('e', ['preventDefault']);
+    event.button = EventUtils.MouseButtons.Right;
+
+    masterInternalTreeEl.query(By.css('.value-container')).triggerEventHandler('contextmenu', event);
+
+    fixture.detectChanges();
+
+    expect(masterInternalTreeEl.componentInstance.isRightMenuVisible).toEqual(true);
+    const menu = masterInternalTreeEl.query(By.css('.node-menu'));
+
+    const menuItemRename: DebugElement = menu.query(By.css('.rename')).parent;
+
+    const eventRename = {button: EventUtils.MouseButtons.Left};
+    menuItemRename.triggerEventHandler('click', eventRename);
+
+    fixture.detectChanges();
+
+    const inputRename = masterInternalTreeEl.query(By.css('input.node-value'));
+    expect(inputRename).toBeDefined();
+    inputRename.triggerEventHandler('blur', {target: {value: ''}});
+
+    fixture.detectChanges();
+
+    expect(masterComponentInstance.tree.value).toEqual('Master');
+  });
+
+  it('should create a leaf child when NewTag operation activated on a branch node', () => {
+    const event = jasmine.createSpyObj('e', ['preventDefault']);
+    event.button = EventUtils.MouseButtons.Right;
+
+    masterInternalTreeEl.query(By.css('.value-container')).triggerEventHandler('contextmenu', event);
+
+    fixture.detectChanges();
+
+    expect(masterInternalTreeEl.componentInstance.isRightMenuVisible).toEqual(true);
+    const menu = masterInternalTreeEl.query(By.css('.node-menu'));
+
+    const menuNewTag: DebugElement = menu.query(By.css('.new-tag')).parent;
+
+    const eventRename = {button: EventUtils.MouseButtons.Left};
+    menuNewTag.triggerEventHandler('click', eventRename);
+
+    fixture.detectChanges();
+
+    const inputRename = masterInternalTreeEl.query(By.css('input.node-value'));
+    expect(inputRename).toBeDefined();
+    inputRename.triggerEventHandler('keyup.enter', {target: {value: 'bla'}});
+
+    fixture.detectChanges();
+
+    expect(masterComponentInstance.tree.children.length).toEqual(3);
+    expect(masterComponentInstance.tree.children[2].value).toEqual('bla');
+    expect(masterInternalTreeEl.queryAll(By.directive(TreeInternalComponent))[2].nativeElement.querySelector('.node-value').innerText).toEqual('bla');
+  });
+
+  it('should create a sibling leaf when NewTag operation was activated on a node that is leaf', () => {
+    const event = jasmine.createSpyObj('e', ['preventDefault']);
+    event.button = EventUtils.MouseButtons.Right;
+
+    const servant1El = masterInternalTreeEl.query(By.directive(TreeInternalComponent));
+
+    servant1El.query(By.css('.value-container')).triggerEventHandler('contextmenu', event);
+
+    fixture.detectChanges();
+
+    expect(servant1El.componentInstance.isRightMenuVisible).toEqual(true);
+    const menu = servant1El.query(By.css('.node-menu'));
+
+    const menuNewTag: DebugElement = menu.query(By.css('.new-tag')).parent;
+
+    const eventRename = {button: EventUtils.MouseButtons.Left};
+    menuNewTag.triggerEventHandler('click', eventRename);
+
+    fixture.detectChanges();
+
+    const inputRename = masterInternalTreeEl.query(By.css('input.node-value'));
+    expect(inputRename).toBeTruthy();
+    inputRename.triggerEventHandler('keyup.enter', {target: {value: 'bla'}});
+
+    fixture.detectChanges();
+
+    expect(masterComponentInstance.tree.children.length).toEqual(3);
+    expect(masterComponentInstance.tree.children[2].value).toEqual('bla');
+    expect(masterInternalTreeEl.queryAll(By.directive(TreeInternalComponent))[2].nativeElement.querySelector('.node-value').innerText).toEqual('bla');
+  });
+
+  it('should not create a node with empty value', () => {
+    const event = jasmine.createSpyObj('e', ['preventDefault']);
+    event.button = EventUtils.MouseButtons.Right;
+
+    masterInternalTreeEl.query(By.css('.value-container')).triggerEventHandler('contextmenu', event);
+
+    fixture.detectChanges();
+
+    expect(masterInternalTreeEl.componentInstance.isRightMenuVisible).toEqual(true);
+    const menu = masterInternalTreeEl.query(By.css('.node-menu'));
+
+    const menuNewTag: DebugElement = menu.query(By.css('.new-tag')).parent;
+
+    const eventRename = {button: EventUtils.MouseButtons.Left};
+    menuNewTag.triggerEventHandler('click', eventRename);
+
+    fixture.detectChanges();
+
+    const inputRename = masterInternalTreeEl.query(By.css('input.node-value'));
+    expect(inputRename).toBeDefined();
+    inputRename.triggerEventHandler('keyup.enter', {target: {value: '\r\n\t '}});
+
+    fixture.detectChanges();
+
+    expect(masterComponentInstance.tree.children.length).toEqual(2);
+    expect(masterComponentInstance.tree.children[0].value).toEqual('Servant#1');
+    expect(masterComponentInstance.tree.children[1].value).toEqual('Servant#2');
+
+    const servantEls = masterInternalTreeEl.queryAll(By.directive(TreeInternalComponent));
+    expect(servantEls.length).toEqual(2);
+    expect(servantEls[0].nativeElement.querySelector('.node-value').innerText).toEqual('Servant#1');
+    expect(servantEls[1].nativeElement.querySelector('.node-value').innerText).toEqual('Servant#2');
+  });
+
+  it('should create a branch node when NewFolder operation activated', () => {
+    const event = jasmine.createSpyObj('e', ['preventDefault']);
+    event.button = EventUtils.MouseButtons.Right;
+
+    masterInternalTreeEl.query(By.css('.value-container')).triggerEventHandler('contextmenu', event);
+
+    fixture.detectChanges();
+
+    expect(masterInternalTreeEl.componentInstance.isRightMenuVisible).toEqual(true);
+    const menu = masterInternalTreeEl.query(By.css('.node-menu'));
+
+    const menuNewTag: DebugElement = menu.query(By.css('.new-folder')).parent;
+
+    const eventRename = {button: EventUtils.MouseButtons.Left};
+    menuNewTag.triggerEventHandler('click', eventRename);
+
+    fixture.detectChanges();
+
+    const inputRename = masterInternalTreeEl.query(By.css('input.node-value'));
+    expect(inputRename).toBeDefined();
+    inputRename.triggerEventHandler('keyup.enter', {target: {value: 'Branch'}});
+
+    fixture.detectChanges();
+
+    expect(masterComponentInstance.tree.children.length).toEqual(3);
+    expect(masterComponentInstance.tree.children[2].value).toEqual('Branch');
+    expect(masterComponentInstance.tree.children[2].isBranch()).toEqual(true);
+    expect(masterComponentInstance.tree.children[2].children).toBeDefined();
+    expect(masterComponentInstance.tree.children[2].children.length).toEqual(0);
+    expect(masterInternalTreeEl.queryAll(By.directive(TreeInternalComponent))[2].nativeElement.querySelector('.node-value').innerText).toEqual('Branch');
+  });
+
+  describe('Static Tree', () => {
+    it('should not show right menu', () => {
+      const event = jasmine.createSpyObj('e', ['preventDefault']);
+      event.button = EventUtils.MouseButtons.Right;
+
+      staticInternalTreeEl.query(By.css('.value-container')).triggerEventHandler('contextmenu', event);
+
+      fixture.detectChanges();
+
+      expect(staticComponentInstance.isRightMenuVisible).toEqual(false);
+      expect(staticInternalTreeEl.query(By.css('.node-menu'))).toEqual(null);
+
+      const childEl = staticInternalTreeEl.query(By.directive(TreeInternalComponent));
+      expect(childEl.componentInstance.isRightMenuVisible).toEqual(false);
+      expect(childEl.query(By.css('.node-menu'))).toEqual(null);
+    });
+
+    it('should not show right menu when settings rightMenu equal to false', () => {
+      const internalTreeChildren = staticInternalTreeEl.queryAll(By.directive(TreeInternalComponent));
+      const eyebowEl = internalTreeChildren[3];
+
+      expect(eyebowEl.componentInstance.tree.value).toEqual('Eyebow');
+      expect(eyebowEl.componentInstance.tree.positionInParent).toEqual(1);
+
+      const event = jasmine.createSpyObj('e', ['preventDefault']);
+      event.button = EventUtils.MouseButtons.Right;
+
+      eyebowEl.query(By.css('.value-container')).triggerEventHandler('contextmenu', event);
+
+      fixture.detectChanges();
+
+      expect(eyebowEl.componentInstance.isRightMenuVisible).toEqual(false);
+      expect(eyebowEl.query(By.css('.node-menu'))).toEqual(null);
+    });
+
+    it('should allow to override static option for it\'s children', () => {
+      const event = jasmine.createSpyObj('e', ['preventDefault']);
+      event.button = EventUtils.MouseButtons.Right;
+
+      const childEl = staticInternalTreeEl.queryAll(By.directive(TreeInternalComponent))[1];
+
+      childEl.query(By.css('.value-container')).triggerEventHandler('contextmenu', event);
+
+      fixture.detectChanges();
+
+      expect(childEl.componentInstance.tree.value).toEqual('Retina');
+      expect(childEl.componentInstance.isRightMenuVisible).toEqual(true);
+      expect(childEl.query(By.css('.node-menu'))).toBeTruthy();
+    });
+
+    it('should not be draggable', () => {
+      const internalTreeChildren = staticInternalTreeEl.queryAll(By.directive(TreeInternalComponent));
+      const eyesEl = internalTreeChildren[0];
+      const lipsEl = internalTreeChildren[4];
+
+      expect(eyesEl.componentInstance.tree.value).toEqual('Eyes');
+      expect(eyesEl.componentInstance.tree.positionInParent).toEqual(0);
+
+      expect(lipsEl.componentInstance.tree.value).toEqual('Lips');
+      expect(lipsEl.componentInstance.tree.positionInParent).toEqual(2);
+
+      expect(staticInternalTreeEl.componentInstance.tree.children[0].value).toEqual('Eyes');
+      expect(staticInternalTreeEl.componentInstance.tree.children[2].value).toEqual('Lips');
+
+      const capturedNode = new CapturedNode(eyesEl.componentInstance.element, eyesEl.componentInstance.tree);
+      nodeDraggableService.fireNodeDragged(capturedNode, lipsEl.componentInstance.element);
+
+      fixture.detectChanges();
+
+      expect(eyesEl.componentInstance.tree.positionInParent).toEqual(0);
+      expect(lipsEl.componentInstance.tree.positionInParent).toEqual(2);
+
+      expect(staticInternalTreeEl.componentInstance.tree.children[0].value).toEqual('Eyes');
+      expect(staticInternalTreeEl.componentInstance.tree.children[2].value).toEqual('Lips');
+
+      const nativeElement = staticInternalTreeEl.nativeElement;
+      const nodeValues = nativeElement.querySelectorAll('.node-value');
+
+      expect(nodeValues[0].innerText).toEqual('Face');
+      expect(nodeValues[1].innerText).toEqual('Eyes');
+      expect(nodeValues[2].innerText).toEqual('Retina');
+      expect(nodeValues[3].innerText).toEqual('Eyelash');
+      expect(nodeValues[4].innerText).toEqual('Eyebow');
+      expect(nodeValues[5].innerText).toEqual('Lips');
+    });
+
+    it('should allow to drag and drop not static elements in a static parent', () => {
+      const internalTreeChildren = staticInternalTreeEl.queryAll(By.directive(TreeInternalComponent));
+      const eyelashEl = internalTreeChildren[2];
+      const eyebowEl = internalTreeChildren[3];
+
+      expect(eyelashEl.componentInstance.tree.value).toEqual('Eyelash');
+      expect(eyelashEl.componentInstance.tree.positionInParent).toEqual(0);
+
+      expect(eyebowEl.componentInstance.tree.value).toEqual('Eyebow');
+      expect(eyebowEl.componentInstance.tree.positionInParent).toEqual(1);
+
+      expect(staticInternalTreeEl.componentInstance.tree.children[1].children[0].value).toEqual('Eyelash');
+      expect(staticInternalTreeEl.componentInstance.tree.children[1].children[1].value).toEqual('Eyebow');
+
+      const capturedNode = new CapturedNode(eyelashEl.componentInstance.element, eyelashEl.componentInstance.tree);
+      nodeDraggableService.fireNodeDragged(capturedNode, eyebowEl.componentInstance.element);
+
+      fixture.detectChanges();
+
+      expect(eyelashEl.componentInstance.tree.positionInParent).toEqual(1);
+      expect(eyebowEl.componentInstance.tree.positionInParent).toEqual(0);
+
+      expect(staticInternalTreeEl.componentInstance.tree.children[1].children[0].value).toEqual('Eyebow');
+      expect(staticInternalTreeEl.componentInstance.tree.children[1].children[1].value).toEqual('Eyelash');
+
+      const nativeElement = staticInternalTreeEl.nativeElement;
+      const nodeValues = nativeElement.querySelectorAll('.node-value');
+
+      expect(nodeValues[0].innerText).toEqual('Face');
+      expect(nodeValues[1].innerText).toEqual('Eyes');
+      expect(nodeValues[2].innerText).toEqual('Retina');
+      expect(nodeValues[3].innerText).toEqual('Eyebow');
+      expect(nodeValues[4].innerText).toEqual('Eyelash');
+      expect(nodeValues[5].innerText).toEqual('Lips');
+    });
+  });
+
+});
+
+@Component({
+  template: `
+  <div><tree id="master" [tree]="tree"></tree></div>
+  <div><tree id="right-menu" [tree]="tree2"></tree></div>
+  <div><tree id="static" [tree]="tree3"></tree></div>
+`
+})
+class TestComponent {
+  public tree: TreeModel = tree;
+  public tree2: TreeModel = tree2;
+  public tree3: TreeModel = tree3;
+
+  public constructor(public treeHolder: ElementRef) {
+  }
+}
diff --git a/test/tree-internal.component.spec.ts b/test/tree-internal.component.spec.ts
index d8ca53b5..cc82de10 100644
--- a/test/tree-internal.component.spec.ts
+++ b/test/tree-internal.component.spec.ts
@@ -21,6 +21,10 @@ let lordInternalTreeEl;
 let lordComponentInstance;
 let faceInternalTreeEl;
 let faceComponentInstance;
+let rightMenuInternalTreeEl;
+let rightMenuComponentInstance;
+let leftMenuInternalTreeEl;
+let leftMenuComponentInstance;
 let nodeMenuService;
 let nodeDraggableService;
 let treeService;
@@ -106,22 +110,6 @@ describe('TreeInternalComponent', () => {
     expect(masterComponentInstance.tree.value).toEqual('Master');
   });
 
-  it('should hide menu when appropriate event has occurred', () => {
-    spyOn(nodeMenuService, 'hideMenuForAllNodesExcept');
-
-    const event = jasmine.createSpyObj('e', ['preventDefault']);
-    event.button = EventUtils.MouseButtons.Right;
-
-    masterInternalTreeEl.query(By.css('.value-container')).triggerEventHandler('contextmenu', event);
-
-    fixture.detectChanges();
-
-    expect(masterComponentInstance.isMenuVisible).toEqual(true);
-    expect(event.preventDefault).toHaveBeenCalled();
-    expect(nodeMenuService.hideMenuForAllNodesExcept).toHaveBeenCalledTimes(1);
-    expect(nodeMenuService.hideMenuForAllNodesExcept).toHaveBeenCalledWith(masterComponentInstance.element);
-  });
-
   it('should unselect selected node when another node is selected', () => {
     const event = jasmine.createSpyObj('e', ['preventDefault']);
     event.button = EventUtils.MouseButtons.Left;
@@ -396,304 +384,6 @@ describe('TreeInternalComponent', () => {
     expect(children.length).toEqual(2);
   });
 
-  it('should show menu on node', () => {
-    const event = jasmine.createSpyObj('e', ['preventDefault']);
-    event.button = EventUtils.MouseButtons.Right;
-
-    masterInternalTreeEl.query(By.css('.value-container')).triggerEventHandler('contextmenu', event);
-
-    fixture.detectChanges();
-
-    expect(masterComponentInstance.isMenuVisible).toEqual(true);
-    const menus = masterInternalTreeEl.queryAll(By.css('.node-menu'));
-
-    expect(menus.length).toEqual(1);
-    expect(menus[0].queryAll(By.css('.node-menu-item')).length).toEqual(4);
-  });
-
-  it('should remove node by click on appropriate menu item', () => {
-    const event = jasmine.createSpyObj('e', ['preventDefault']);
-    event.button = EventUtils.MouseButtons.Right;
-
-    const servantEls = masterInternalTreeEl.queryAll(By.directive(TreeInternalComponent));
-    const servant1El = servantEls[0];
-
-    servant1El.query(By.css('.value-container')).triggerEventHandler('contextmenu', event);
-
-    fixture.detectChanges();
-
-    expect(servant1El.componentInstance.isMenuVisible).toEqual(true);
-    const menu = servant1El.query(By.css('.node-menu'));
-
-    const menuItemRemove: DebugElement = menu.query(By.css('.remove')).parent;
-
-    const eventRemove = {button: EventUtils.MouseButtons.Left};
-    menuItemRemove.triggerEventHandler('click', eventRemove);
-
-    fixture.detectChanges();
-
-    const remainedSevantEls = masterInternalTreeEl.queryAll(By.directive(TreeInternalComponent));
-    expect(remainedSevantEls.length).toEqual(1);
-    expect(remainedSevantEls[0].componentInstance.tree.value).toEqual('Servant#2');
-  });
-
-  it('should hide menu on click outside of menu', () => {
-    const event = jasmine.createSpyObj('e', ['preventDefault']);
-    event.button = EventUtils.MouseButtons.Right;
-
-    const servantEls = masterInternalTreeEl.queryAll(By.directive(TreeInternalComponent));
-    const servant1El = servantEls[0];
-
-    servant1El.query(By.css('.value-container')).triggerEventHandler('contextmenu', event);
-
-    fixture.detectChanges();
-
-    expect(servant1El.componentInstance.isMenuVisible).toEqual(true);
-    expect(servant1El.query(By.css('.node-menu'))).toBeDefined();
-
-    nodeMenuService.fireMenuEvent(null, NodeMenuAction.Close);
-
-    fixture.detectChanges();
-
-    expect(servant1El.componentInstance.isMenuVisible).toEqual(false);
-    expect(servant1El.query(By.css('.node-menu'))).toBeNull();
-  });
-
-  it('should rename node on enter', () => {
-    const event = jasmine.createSpyObj('e', ['preventDefault']);
-    event.button = EventUtils.MouseButtons.Right;
-
-    masterInternalTreeEl.query(By.css('.value-container')).triggerEventHandler('contextmenu', event);
-
-    fixture.detectChanges();
-
-    expect(masterInternalTreeEl.componentInstance.isMenuVisible).toEqual(true);
-    const menu = masterInternalTreeEl.query(By.css('.node-menu'));
-
-    const menuItemRename: DebugElement = menu.query(By.css('.rename')).parent;
-
-    const eventRename = {button: EventUtils.MouseButtons.Left};
-    menuItemRename.triggerEventHandler('click', eventRename);
-
-    fixture.detectChanges();
-
-    const inputRename = masterInternalTreeEl.query(By.css('input.node-value'));
-    expect(inputRename).toBeDefined();
-    inputRename.triggerEventHandler('keyup.enter', {target: {value: 'bla'}});
-
-    fixture.detectChanges();
-
-    expect(masterComponentInstance.tree.value).toEqual('bla');
-  });
-
-  it('should rename node on blur', () => {
-    const event = jasmine.createSpyObj('e', ['preventDefault']);
-    event.button = EventUtils.MouseButtons.Right;
-
-    masterInternalTreeEl.query(By.css('.value-container')).triggerEventHandler('contextmenu', event);
-
-    fixture.detectChanges();
-
-    expect(masterInternalTreeEl.componentInstance.isMenuVisible).toEqual(true);
-    const menu = masterInternalTreeEl.query(By.css('.node-menu'));
-
-    const menuItemRename: DebugElement = menu.query(By.css('.rename')).parent;
-
-    const eventRename = {button: EventUtils.MouseButtons.Left};
-    menuItemRename.triggerEventHandler('click', eventRename);
-
-    fixture.detectChanges();
-
-    const inputRename = masterInternalTreeEl.query(By.css('input.node-value'));
-    expect(inputRename).toBeDefined();
-    inputRename.triggerEventHandler('blur', {target: {value: 'bla'}});
-
-    fixture.detectChanges();
-
-    expect(masterComponentInstance.tree.value).toEqual('bla');
-  });
-
-  it('should cancel renaming node on escape pressed', () => {
-    const event = jasmine.createSpyObj('e', ['preventDefault']);
-    event.button = EventUtils.MouseButtons.Right;
-
-    masterInternalTreeEl.query(By.css('.value-container')).triggerEventHandler('contextmenu', event);
-
-    fixture.detectChanges();
-
-    expect(masterInternalTreeEl.componentInstance.isMenuVisible).toEqual(true);
-    const menu = masterInternalTreeEl.query(By.css('.node-menu'));
-
-    const menuItemRename: DebugElement = menu.query(By.css('.rename')).parent;
-
-    const eventRename = {button: EventUtils.MouseButtons.Left};
-    menuItemRename.triggerEventHandler('click', eventRename);
-
-    fixture.detectChanges();
-
-    const inputRename = masterInternalTreeEl.query(By.css('input.node-value'));
-    expect(inputRename).toBeDefined();
-    inputRename.nativeElement.value = '121212';
-    inputRename.triggerEventHandler('keyup.esc', {target: {value: 'bla'}});
-
-    fixture.detectChanges();
-
-    expect(masterComponentInstance.tree.value).toEqual('Master');
-  });
-
-  it('should not rename node on empty input', () => {
-    const event = jasmine.createSpyObj('e', ['preventDefault']);
-    event.button = EventUtils.MouseButtons.Right;
-
-    masterInternalTreeEl.query(By.css('.value-container')).triggerEventHandler('contextmenu', event);
-
-    fixture.detectChanges();
-
-    expect(masterInternalTreeEl.componentInstance.isMenuVisible).toEqual(true);
-    const menu = masterInternalTreeEl.query(By.css('.node-menu'));
-
-    const menuItemRename: DebugElement = menu.query(By.css('.rename')).parent;
-
-    const eventRename = {button: EventUtils.MouseButtons.Left};
-    menuItemRename.triggerEventHandler('click', eventRename);
-
-    fixture.detectChanges();
-
-    const inputRename = masterInternalTreeEl.query(By.css('input.node-value'));
-    expect(inputRename).toBeDefined();
-    inputRename.triggerEventHandler('blur', {target: {value: ''}});
-
-    fixture.detectChanges();
-
-    expect(masterComponentInstance.tree.value).toEqual('Master');
-  });
-
-  it('should create a leaf child when NewTag operation activated on a branch node', () => {
-    const event = jasmine.createSpyObj('e', ['preventDefault']);
-    event.button = EventUtils.MouseButtons.Right;
-
-    masterInternalTreeEl.query(By.css('.value-container')).triggerEventHandler('contextmenu', event);
-
-    fixture.detectChanges();
-
-    expect(masterInternalTreeEl.componentInstance.isMenuVisible).toEqual(true);
-    const menu = masterInternalTreeEl.query(By.css('.node-menu'));
-
-    const menuNewTag: DebugElement = menu.query(By.css('.new-tag')).parent;
-
-    const eventRename = {button: EventUtils.MouseButtons.Left};
-    menuNewTag.triggerEventHandler('click', eventRename);
-
-    fixture.detectChanges();
-
-    const inputRename = masterInternalTreeEl.query(By.css('input.node-value'));
-    expect(inputRename).toBeDefined();
-    inputRename.triggerEventHandler('keyup.enter', {target: {value: 'bla'}});
-
-    fixture.detectChanges();
-
-    expect(masterComponentInstance.tree.children.length).toEqual(3);
-    expect(masterComponentInstance.tree.children[2].value).toEqual('bla');
-    expect(masterInternalTreeEl.queryAll(By.directive(TreeInternalComponent))[2].nativeElement.querySelector('.node-value').innerText).toEqual('bla');
-  });
-
-  it('should create a sibling leaf when NewTag operation was activated on a node that is leaf', () => {
-    const event = jasmine.createSpyObj('e', ['preventDefault']);
-    event.button = EventUtils.MouseButtons.Right;
-
-    const servant1El = masterInternalTreeEl.query(By.directive(TreeInternalComponent));
-
-    servant1El.query(By.css('.value-container')).triggerEventHandler('contextmenu', event);
-
-    fixture.detectChanges();
-
-    expect(servant1El.componentInstance.isMenuVisible).toEqual(true);
-    const menu = servant1El.query(By.css('.node-menu'));
-
-    const menuNewTag: DebugElement = menu.query(By.css('.new-tag')).parent;
-
-    const eventRename = {button: EventUtils.MouseButtons.Left};
-    menuNewTag.triggerEventHandler('click', eventRename);
-
-    fixture.detectChanges();
-
-    const inputRename = masterInternalTreeEl.query(By.css('input.node-value'));
-    expect(inputRename).toBeTruthy();
-    inputRename.triggerEventHandler('keyup.enter', {target: {value: 'bla'}});
-
-    fixture.detectChanges();
-
-    expect(masterComponentInstance.tree.children.length).toEqual(3);
-    expect(masterComponentInstance.tree.children[2].value).toEqual('bla');
-    expect(masterInternalTreeEl.queryAll(By.directive(TreeInternalComponent))[2].nativeElement.querySelector('.node-value').innerText).toEqual('bla');
-  });
-
-  it('should not create a node with empty value', () => {
-    const event = jasmine.createSpyObj('e', ['preventDefault']);
-    event.button = EventUtils.MouseButtons.Right;
-
-    masterInternalTreeEl.query(By.css('.value-container')).triggerEventHandler('contextmenu', event);
-
-    fixture.detectChanges();
-
-    expect(masterInternalTreeEl.componentInstance.isMenuVisible).toEqual(true);
-    const menu = masterInternalTreeEl.query(By.css('.node-menu'));
-
-    const menuNewTag: DebugElement = menu.query(By.css('.new-tag')).parent;
-
-    const eventRename = {button: EventUtils.MouseButtons.Left};
-    menuNewTag.triggerEventHandler('click', eventRename);
-
-    fixture.detectChanges();
-
-    const inputRename = masterInternalTreeEl.query(By.css('input.node-value'));
-    expect(inputRename).toBeDefined();
-    inputRename.triggerEventHandler('keyup.enter', {target: {value: '\r\n\t '}});
-
-    fixture.detectChanges();
-
-    expect(masterComponentInstance.tree.children.length).toEqual(2);
-    expect(masterComponentInstance.tree.children[0].value).toEqual('Servant#1');
-    expect(masterComponentInstance.tree.children[1].value).toEqual('Servant#2');
-
-    const servantEls = masterInternalTreeEl.queryAll(By.directive(TreeInternalComponent));
-    expect(servantEls.length).toEqual(2);
-    expect(servantEls[0].nativeElement.querySelector('.node-value').innerText).toEqual('Servant#1');
-    expect(servantEls[1].nativeElement.querySelector('.node-value').innerText).toEqual('Servant#2');
-  });
-
-  it('should create a branch node when NewFolder operation activated', () => {
-    const event = jasmine.createSpyObj('e', ['preventDefault']);
-    event.button = EventUtils.MouseButtons.Right;
-
-    masterInternalTreeEl.query(By.css('.value-container')).triggerEventHandler('contextmenu', event);
-
-    fixture.detectChanges();
-
-    expect(masterInternalTreeEl.componentInstance.isMenuVisible).toEqual(true);
-    const menu = masterInternalTreeEl.query(By.css('.node-menu'));
-
-    const menuNewTag: DebugElement = menu.query(By.css('.new-folder')).parent;
-
-    const eventRename = {button: EventUtils.MouseButtons.Left};
-    menuNewTag.triggerEventHandler('click', eventRename);
-
-    fixture.detectChanges();
-
-    const inputRename = masterInternalTreeEl.query(By.css('input.node-value'));
-    expect(inputRename).toBeDefined();
-    inputRename.triggerEventHandler('keyup.enter', {target: {value: 'Branch'}});
-
-    fixture.detectChanges();
-
-    expect(masterComponentInstance.tree.children.length).toEqual(3);
-    expect(masterComponentInstance.tree.children[2].value).toEqual('Branch');
-    expect(masterComponentInstance.tree.children[2].isBranch()).toEqual(true);
-    expect(masterComponentInstance.tree.children[2].children).toBeDefined();
-    expect(masterComponentInstance.tree.children[2].children.length).toEqual(0);
-    expect(masterInternalTreeEl.queryAll(By.directive(TreeInternalComponent))[2].nativeElement.querySelector('.node-value').innerText).toEqual('Branch');
-  });
-
   it('shouldn\'t show root of the tree', () => {
     expect(faceComponentInstance.tree.isRoot()).toEqual(true, 'Element that has rootless class should be a root of the tree');
 
@@ -720,11 +410,11 @@ describe('TreeInternalComponent', () => {
 
       fixture.detectChanges();
 
-      expect(faceComponentInstance.isMenuVisible).toEqual(false);
+      expect(faceComponentInstance.isRightMenuVisible).toEqual(false);
       expect(faceInternalTreeEl.query(By.css('.node-menu'))).toEqual(null);
 
       const childEl = faceInternalTreeEl.query(By.directive(TreeInternalComponent));
-      expect(childEl.componentInstance.isMenuVisible).toEqual(false);
+      expect(childEl.componentInstance.isRightMenuVisible).toEqual(false);
       expect(childEl.query(By.css('.node-menu'))).toEqual(null);
     });
 
@@ -739,7 +429,7 @@ describe('TreeInternalComponent', () => {
       fixture.detectChanges();
 
       expect(childEl.componentInstance.tree.value).toEqual('Retina');
-      expect(childEl.componentInstance.isMenuVisible).toEqual(true);
+      expect(childEl.componentInstance.isRightMenuVisible).toEqual(true);
       expect(childEl.query(By.css('.node-menu'))).toBeTruthy();
     });
 
diff --git a/test/tree.types.spec.ts b/test/tree.types.spec.ts
index 02d109f7..3e79a677 100644
--- a/test/tree.types.spec.ts
+++ b/test/tree.types.spec.ts
@@ -1,7 +1,7 @@
 import { TreeModelSettings, TreeModel, FoldingType } from '../src/tree.types';
 
 describe('TreeModelSettings', () => {
-  it('should correctly merge TreeModelSettings: static is false by default', () => {
+  it('should correctly merge TreeModelSettings - default values: static - false; leftMenu - false; rightMenu - true', () => {
     const treeModelA: TreeModel = {
       value: "42"
     };
@@ -10,25 +10,29 @@ describe('TreeModelSettings', () => {
       value: "12"
     };
 
-    expect(TreeModelSettings.merge(treeModelA, treeModelB)).toEqual({static: false});
+    expect(TreeModelSettings.merge(treeModelA, treeModelB)).toEqual({static: false, leftMenu: false, rightMenu: true});
   });
 
   it('should correctly merge TreeModelSettings: first settings source has higher priority', () => {
     const treeModelA: TreeModel = {
       value: "42",
       settings: {
-        static: true
+        static: true,
+        leftMenu: true,
+        rightMenu: true
       }
     };
 
     const treeModelB: TreeModel = {
       value: "12",
       settings: {
-        static: false
+        static: false,
+        leftMenu: false,
+        rightMenu: false
       }
     };
 
-    expect(TreeModelSettings.merge(treeModelA, treeModelB)).toEqual({static: true});
+    expect(TreeModelSettings.merge(treeModelA, treeModelB)).toEqual({static: true, leftMenu: true, rightMenu: true});
   });
 
   it('should correctly merge TreeModelSettings: second settings source has priority if first settings source doesn\'t have the option', () => {
@@ -39,11 +43,13 @@ describe('TreeModelSettings', () => {
     const treeModelB: TreeModel = {
       value: "12",
       settings: {
-        static: true
+        static: true,
+        leftMenu: true,
+        rightMenu: false
       }
     };
 
-    expect(TreeModelSettings.merge(treeModelA, treeModelB)).toEqual({static: true});
+    expect(TreeModelSettings.merge(treeModelA, treeModelB)).toEqual({static: true, leftMenu: true, rightMenu: false});
   });
 });
 
@@ -53,4 +59,4 @@ describe('FoldingType', () => {
     expect(FoldingType.Collapsed.cssClass).toEqual('node-collapsed');
     expect(FoldingType.Leaf.cssClass).toEqual('node-leaf');
   });
-});
\ No newline at end of file
+});