mirror of
https://github.com/lxsang/antos-frontend.git
synced 2025-10-31 18:35:44 +01:00
752 lines
22 KiB
TypeScript
752 lines
22 KiB
TypeScript
import * as JQuery from "../src/libs/jquery-3.2.1.min";
|
|
import { OS as _OS_ } from "../dist/antos";
|
|
// some global variable
|
|
const _w_ = window as any;
|
|
_w_.$ = JQuery;
|
|
const OS = _OS_ as any;
|
|
_w_.OS = OS;
|
|
|
|
interface GenericObject<T> {
|
|
[propName: string]: T;
|
|
}
|
|
// an example tag
|
|
class ExampleTag extends OS.GUI.AFXTag {
|
|
private _prop1: number;
|
|
private _prop2: string;
|
|
constructor() {
|
|
super();
|
|
}
|
|
set prop1(v: number) {
|
|
this._prop1 = v;
|
|
}
|
|
set prop2(v: string) {
|
|
this._prop2 = v;
|
|
}
|
|
get prop1(): number {
|
|
return this._prop1;
|
|
}
|
|
get prop2(): string {
|
|
return this._prop2;
|
|
}
|
|
layout() {
|
|
return [];
|
|
}
|
|
init() {
|
|
this._prop1 = 0;
|
|
this._prop2 = "test";
|
|
}
|
|
mount() {}
|
|
}
|
|
|
|
OS.GUI.tag.define("afx-example-tag", ExampleTag);
|
|
|
|
test("Test base tag getter/setter", () => {
|
|
const tag = new ExampleTag();
|
|
tag.uify();
|
|
expect(tag.aid).toBeDefined();
|
|
tag.aid = "test";
|
|
expect(tag.aid).toBe("test");
|
|
expect(tag.prop1).toBe(0);
|
|
expect(tag.prop2).toBe("test");
|
|
tag.set({
|
|
prop1: 10,
|
|
prop2: "Hello",
|
|
prop3: "test",
|
|
});
|
|
expect(tag.prop1).toBe(10);
|
|
expect(tag.prop2).toBe("Hello");
|
|
expect(tag.prop3).toBeUndefined();
|
|
tag.tooltip = "tooltip";
|
|
expect(tag.tooltip).toBeUndefined();
|
|
expect($(tag).attr("tooltip")).toBe("tooltip");
|
|
});
|
|
|
|
// Button test
|
|
|
|
test("Test button tag setter/getter", () => {
|
|
const bt = new OS.GUI.tag.ButtonTag();
|
|
bt.uify();
|
|
expect(bt.enable).toBe(true);
|
|
expect(bt.toggle).toBe(false);
|
|
expect(bt).toBeDefined();
|
|
bt.text = "test";
|
|
expect(bt.text).toBe("test");
|
|
bt.enable = true;
|
|
expect(bt.enable).toBe(true);
|
|
bt.enable = false;
|
|
expect(bt.enable).toBe(false);
|
|
bt.icon = "test";
|
|
bt.iconclass = "test";
|
|
expect(bt.icon).toBeUndefined();
|
|
expect(bt.iconclass).toBeUndefined();
|
|
bt.selected = true;
|
|
expect(bt.selected).toBe(true);
|
|
bt.selected = false;
|
|
expect(bt.selected).toBe(false);
|
|
|
|
bt.toggle = true;
|
|
expect(bt.toggle).toBe(true);
|
|
bt.toggle = false;
|
|
expect(bt.toggle).toBe(false);
|
|
});
|
|
|
|
test("Test button tag behavior", () => {
|
|
const bt = new OS.GUI.tag.ButtonTag();
|
|
bt.uify();
|
|
const cb = jest.fn();
|
|
bt.onbtclick = cb;
|
|
$("button", bt).trigger("click");
|
|
expect(cb).toBeCalledTimes(1);
|
|
const data = {
|
|
text: "name",
|
|
onbtclick: jest.fn(),
|
|
};
|
|
bt.set(data);
|
|
$("button", bt).trigger("click");
|
|
expect(data.onbtclick).toBeCalledTimes(1);
|
|
});
|
|
|
|
// Label test
|
|
|
|
test("Test label tag setter/getter", () => {
|
|
const lbl = new OS.GUI.tag.LabelTag();
|
|
expect(lbl).toBeDefined();
|
|
lbl.uify();
|
|
expect(lbl.icon).toBeUndefined();
|
|
expect(lbl.iconclass).toBeUndefined();
|
|
expect(lbl.text).toBeUndefined();
|
|
lbl.icon = "test";
|
|
lbl.iconclass = "test";
|
|
lbl.text = "test";
|
|
expect(lbl.icon).toBeUndefined();
|
|
expect(lbl.iconclass).toBeUndefined();
|
|
expect(lbl.text).toBe("test");
|
|
});
|
|
|
|
// switch test
|
|
test("Test switcher getter/setter", () => {
|
|
const sw = new OS.GUI.tag.SwitchTag();
|
|
sw.uify();
|
|
expect(sw.swon).toBe(false);
|
|
sw.swon = true;
|
|
expect(sw.swon).toBe(true);
|
|
sw.swon = false;
|
|
expect(sw.swon).toBe(false);
|
|
expect(sw.enable).toBe(true);
|
|
sw.enable = false;
|
|
expect(sw.enable).toBe(false);
|
|
});
|
|
|
|
test("Test switch behavior", () => {
|
|
const sw = new OS.GUI.tag.SwitchTag();
|
|
sw.uify();
|
|
const cb = jest.fn();
|
|
sw.onswchange = cb;
|
|
$("span", sw).trigger("click");
|
|
expect(cb).toBeCalledTimes(1);
|
|
expect(sw.swon).toBe(true);
|
|
});
|
|
|
|
// List view item test
|
|
test("Test simple list view item setter/getter", () => {
|
|
const item = new OS.GUI.tag.SimpleListItemTag();
|
|
item.uify();
|
|
expect(item.closable).toBe(false);
|
|
expect(item.selected).toBe(false);
|
|
item.closable = true;
|
|
expect(item.closable).toBe(true);
|
|
expect(item.data).toBeDefined();
|
|
item.closable = false;
|
|
item.selected = false;
|
|
const data = { text: "Hello", closable: true, selected: true };
|
|
item.data = data;
|
|
expect(item.closable).toBe(true);
|
|
expect(item.selected).toBe(true);
|
|
expect(($("afx-label", item)[0] as any).text).toBe("Hello");
|
|
});
|
|
|
|
test("Test simple list view item behaviour", () => {
|
|
const item = new OS.GUI.tag.SimpleListItemTag();
|
|
item.uify();
|
|
const cb = jest.fn();
|
|
item.onitemselect = cb;
|
|
item.onitemclick = cb;
|
|
item.onitemdbclick = cb;
|
|
item.onitemclose = cb;
|
|
const data = { text: "hello", closable: true, selected: true };
|
|
item.data = data;
|
|
expect(cb).toBeCalledTimes(1);
|
|
$("li", item).trigger("click");
|
|
expect(cb).toBeCalledTimes(2);
|
|
$("li", item).trigger("dblclick");
|
|
expect(cb).toBeCalledTimes(3);
|
|
$("i.closable", item).trigger("click");
|
|
expect(cb).toBeCalledTimes(4);
|
|
});
|
|
|
|
// list view test
|
|
test("Test list view setter/getter", () => {
|
|
const item = new OS.GUI.tag.ListViewTag();
|
|
item.uify();
|
|
expect(item.data).toBeDefined();
|
|
expect(item.data.length).toBe(0);
|
|
expect(item.multiselect).toBe(false);
|
|
expect(item.dropdown).toBe(false);
|
|
expect(item.selected).toBe(-1);
|
|
expect(item.dragndrop).toBe(false);
|
|
expect(item.itemtag).toBe("afx-list-item");
|
|
expect(item.selectedItem).toBeUndefined();
|
|
expect(item.selectedItems).toBeDefined();
|
|
expect(item.selectedItems.length).toBe(0);
|
|
item.multiselect = true;
|
|
expect(item.multiselect).toBe(true);
|
|
item.dragndrop = true;
|
|
item.dropdown = true;
|
|
item.itemtag = "afx-sample";
|
|
expect(item.multiselect).toBe(false);
|
|
expect(item.dropdown).toBe(true);
|
|
expect(item.dragndrop).toBe(true);
|
|
expect(item.itemtag).toBe("afx-sample");
|
|
const data: GenericObject<string>[] = [{ text: "Item 1" }];
|
|
item.data = data;
|
|
expect(item.data).toBe(data);
|
|
const dbot = { text: "bot" };
|
|
const dtop = { text: "top" };
|
|
item.push(dbot);
|
|
item.unshift(dtop);
|
|
expect(item.data[2]).toBe(dbot);
|
|
expect(item.data[0]).toBe(dtop);
|
|
item.delete(item.data[2].domel);
|
|
expect(item.data.length).toBe(2);
|
|
});
|
|
|
|
test("Test list view behaviour", () => {
|
|
const item = new OS.GUI.tag.ListViewTag();
|
|
item.uify();
|
|
const cb = jest.fn();
|
|
item.onlistselect = cb;
|
|
item.onlistdbclick = cb;
|
|
item.onlist;
|
|
const data = [
|
|
{ text: "Item 1", closable: true, selected: false },
|
|
{ text: "Item 2", closable: true, selected: true },
|
|
{ text: "Item 3", closable: true, selected: false },
|
|
];
|
|
item.data = data;
|
|
expect(item.data).toBe(data);
|
|
expect(cb).toBeCalledTimes(1);
|
|
expect(item.selectedItem).toBe((data[1] as any).domel);
|
|
expect(item.selectedItems.length).toBe(1);
|
|
expect(item.selectedItems[0]).toBe((data[1] as any).domel);
|
|
expect(item.selected).toBe(1);
|
|
item.multiselect = true;
|
|
data[2].selected = true;
|
|
item.data = data;
|
|
expect(cb).toBeCalledTimes(3);
|
|
expect(item.selectedItem).toBe((data[2] as any).domel);
|
|
expect(item.selectedItems.length).toBe(2);
|
|
var el = (data[0] as any).domel;
|
|
$("li", el).trigger("click");
|
|
expect(cb).toBeCalledTimes(4);
|
|
expect(item.selectedItems.length).toBe(3);
|
|
expect(item.selectedItem).toBe((data[0] as any).domel);
|
|
item.unselect();
|
|
expect(item.selectedItems.length).toBe(0);
|
|
expect(item.selectedItem).toBeUndefined();
|
|
item.multiselect = false;
|
|
data[0].selected = true;
|
|
data[2].selected = true;
|
|
item.dragndrop = true;
|
|
item.data = data;
|
|
expect(item.selectedItem).toBe((data[2] as any).domel);
|
|
expect(item.selectedItems.length).toBe(1);
|
|
el = (data[1] as any).domel;
|
|
$("li", el).trigger("dblclick");
|
|
expect(cb).toBeCalledTimes(8);
|
|
expect(item.selectedItem).toBe(el);
|
|
item.selectPrev();
|
|
expect(item.selectedItem).toBe((data[0] as any).domel);
|
|
expect(item.selectedItems.length).toBe(1);
|
|
item.selectNext();
|
|
expect(item.selectedItem).toBe((data[1] as any).domel);
|
|
expect(item.selectedItems.length).toBe(1);
|
|
// close an element
|
|
var close_cb = jest.fn((x) => false);
|
|
item.onitemclose = close_cb;
|
|
el = (data[0] as any).domel;
|
|
$("i.closable", el).trigger("click");
|
|
expect(close_cb).toBeCalledTimes(1);
|
|
expect(item.data.length).toBe(3);
|
|
expect(item.selectedItem).toBe((data[1] as any).domel);
|
|
close_cb = jest.fn((x) => true);
|
|
item.onitemclose = close_cb;
|
|
$("i.closable", el).trigger("click");
|
|
expect(item.data.length).toBe(2);
|
|
expect(item.selectedItem).toBe((data[0] as any).domel);
|
|
expect(close_cb).toBeCalledTimes(1);
|
|
el = (data[0] as any).domel;
|
|
$("i.closable", el).trigger("click");
|
|
expect(item.data.length).toBe(1);
|
|
expect(item.selectedItem).toBeUndefined();
|
|
expect(close_cb).toBeCalledTimes(2);
|
|
});
|
|
|
|
// test Menu item
|
|
function get_treedata(): GenericObject<any> {
|
|
return {
|
|
name: "My Tree",
|
|
nodes: [
|
|
{ name: "child 1", iconclass: "fa fa-car" },
|
|
{ name: "child 2" },
|
|
{
|
|
name: "sub tree 1",
|
|
nodes: [
|
|
{
|
|
name: "sub sub tree 1",
|
|
nodes: [{ name: "leaf 1" }, { name: "leaf 2" }],
|
|
},
|
|
{ name: "leaf 3" },
|
|
{ name: "leaf 4" },
|
|
],
|
|
},
|
|
],
|
|
};
|
|
}
|
|
test("Test menu item setter/getter", () => {
|
|
const treedata = get_treedata();
|
|
const item = new OS.GUI.tag.SimpleMenuEntryTag();
|
|
item.uify();
|
|
expect(item.data).toBeUndefined();
|
|
expect(item.switch).toBe(false);
|
|
expect(item.radio).toBe(false);
|
|
expect(item.checked).toBe(false);
|
|
expect(item.nodes).toBeUndefined();
|
|
expect(item.parent).toBeUndefined();
|
|
expect(item.root).toBeUndefined();
|
|
const leaf = { name: "child 1", switch: true, radio: true };
|
|
item.data = leaf;
|
|
expect(item.data).toBe(leaf);
|
|
expect(item.data.nodes).toBeUndefined();
|
|
expect(item.switch).toBe(true);
|
|
expect(item.radio).toBe(true);
|
|
item.data = treedata;
|
|
expect(item.nodes).toBe(treedata.nodes);
|
|
});
|
|
|
|
test("Test menu item behaviour", () => {
|
|
const item = new OS.GUI.tag.SimpleMenuEntryTag();
|
|
item.uify();
|
|
const treedata = get_treedata();
|
|
item.data = treedata;
|
|
const cb = jest.fn();
|
|
item.onmenuselect = cb;
|
|
item.onchildselect = cb;
|
|
$(">li>a", item).trigger("click");
|
|
expect(cb).toBeCalledTimes(1);
|
|
const node0 = treedata.nodes[0].domel;
|
|
const node1 = treedata.nodes[1].domel;
|
|
node0.switch = true;
|
|
node1.switch = true;
|
|
expect(node0.checked).toBe(false);
|
|
node1.checked = true;
|
|
$(">li>a", node0).trigger("click");
|
|
expect(cb).toBeCalledTimes(2);
|
|
expect(node0.checked).toBe(true);
|
|
expect(node1.checked).toBe(true);
|
|
|
|
// check radio option
|
|
node0.switch = false;
|
|
node1.switch = false;
|
|
node0.radio = true;
|
|
node1.radio = true;
|
|
node0.checked = false;
|
|
expect(node0.parent).toBe(item);
|
|
expect(node1.parent).toBe(item);
|
|
expect(node0.checked).toBe(false);
|
|
expect(node1.checked).toBe(true);
|
|
$(">li>a", node0).trigger("click");
|
|
expect(cb).toBeCalledTimes(3);
|
|
expect(node0.checked).toBe(true);
|
|
expect(node1.checked).toBe(false);
|
|
});
|
|
|
|
// test Menu
|
|
test("Test menu setter/getter", () => {
|
|
const item = new OS.GUI.tag.MenuTag();
|
|
item.uify();
|
|
const treedata = get_treedata();
|
|
item.items = [treedata];
|
|
expect(item.items[0]).toBe(treedata);
|
|
expect(item.context).toBe(false);
|
|
item.context = true;
|
|
expect(item.context).toBe(true);
|
|
expect(item.contentag).toBe("afx-menu-entry");
|
|
item.contentag = "afx-sample";
|
|
expect(item.contentag).toBe("afx-sample");
|
|
const extra_data_top: GenericObject<string> = { name: "test" };
|
|
item.unshift(extra_data_top);
|
|
expect(item.items.length).toBe(2);
|
|
expect(item.items[0]).toBe(extra_data_top);
|
|
const extra_data_bot: GenericObject<string> = { name: "test" };
|
|
item.push(extra_data_bot);
|
|
expect(item.items[2]).toBe(extra_data_bot);
|
|
item.delete(extra_data_top.domel);
|
|
expect(item.items[0] === extra_data_top).toBe(false);
|
|
});
|
|
|
|
test("Test menu behavior", () => {
|
|
const item = new OS.GUI.tag.MenuTag();
|
|
const treedata = get_treedata();
|
|
item.uify();
|
|
item.items = [treedata];
|
|
const cb = jest.fn();
|
|
item.onmenuselect = cb;
|
|
const node0 = treedata.nodes[0].domel;
|
|
$(">li>a", node0).trigger("click");
|
|
expect(cb).toBeCalledTimes(1);
|
|
});
|
|
|
|
// Gridview tag
|
|
test("Test gridview cell setter/getter", () => {
|
|
const cell = new OS.GUI.tag.SimpleGridCellTag();
|
|
cell.uify();
|
|
expect(cell.selected).toBe(false);
|
|
cell.selected = true;
|
|
expect(cell.selected).toBe(true);
|
|
const celldata = { text: "test" };
|
|
cell.data = celldata;
|
|
expect(cell.data).toBe(celldata);
|
|
});
|
|
|
|
test("Test gridview cell behavior", () => {
|
|
const cell = new OS.GUI.tag.SimpleGridCellTag();
|
|
cell.uify();
|
|
const celldata = { text: "test" };
|
|
cell.data = celldata;
|
|
const cb = jest.fn();
|
|
cell.oncellselect = cb;
|
|
cell.oncelldbclick = cb;
|
|
cell.selected = true;
|
|
expect(cb).toBeCalledTimes(1);
|
|
$(cell).trigger("click");
|
|
expect(cb).toBeCalledTimes(2);
|
|
$(cell).trigger("dblclick");
|
|
expect(cb).toBeCalledTimes(3);
|
|
});
|
|
|
|
function get_grid_data(): GenericObject<any> {
|
|
return {
|
|
header: [
|
|
{ text: "header 1" },
|
|
{ text: "header 2" },
|
|
{ text: "header 3" },
|
|
],
|
|
rows: [
|
|
[{ text: "text 1" }, { text: "text 2" }, { text: "text 3" }],
|
|
[{ text: "text 4" }, { text: "text 5" }, { text: "text 6" }],
|
|
[{ text: "text 7" }, { text: "text 8" }, { text: "text 9" }],
|
|
],
|
|
};
|
|
}
|
|
test("Test gridview setter/getter", () => {
|
|
const grid = new OS.GUI.tag.GridViewTag();
|
|
grid.uify();
|
|
expect(grid.headeritem).toBe("afx-grid-cell");
|
|
expect(grid.cellitem).toBe("afx-grid-cell");
|
|
expect(grid.selectedCell).toBe(undefined);
|
|
expect(grid.selectedRow).toBe(undefined);
|
|
expect(grid.selectedRows).toBeDefined();
|
|
expect(grid.selectedRows.length).toBe(0);
|
|
expect(grid.rows).toBeDefined();
|
|
expect(grid.rows.length).toBe(0);
|
|
expect(grid.multiselect).toBe(false);
|
|
grid.multiselect = true;
|
|
const data = get_grid_data();
|
|
data.rows[1][0].selected = true;
|
|
data.rows[2][0].selected = true;
|
|
grid.set(data);
|
|
const row = data.rows[2];
|
|
const cell = row[0];
|
|
expect(grid.rows).toBe(data.rows);
|
|
expect(grid.header).toBe(data.header);
|
|
expect(grid.selectedCell).toBe(cell.domel);
|
|
expect(grid.selectedRow).toBe(row.domel);
|
|
expect(grid.selectedRows.length).toBe(2);
|
|
const toprow: any = [
|
|
{ text: "text -3" },
|
|
{ text: "text -2" },
|
|
{ text: "text -1" },
|
|
];
|
|
const botrow: any = [
|
|
{ text: "text 10" },
|
|
{ text: "text 11" },
|
|
{ text: "text 12" },
|
|
];
|
|
grid.unshift(toprow);
|
|
grid.push(botrow);
|
|
expect(grid.rows.length).toBe(5);
|
|
grid.delete(toprow.domel);
|
|
grid.delete(botrow.domel);
|
|
expect(grid.rows.length).toBe(3);
|
|
expect(grid.rows.includes(toprow.domel)).toBe(false);
|
|
expect(grid.rows.includes(botrow.domel)).toBe(false);
|
|
grid.headeritem = "afx-sample";
|
|
grid.cellitem = "afx-sample";
|
|
expect(grid.headeritem).toBe("afx-sample");
|
|
expect(grid.cellitem).toBe("afx-sample");
|
|
});
|
|
|
|
test("Test gridview behavior", () => {
|
|
const grid = new OS.GUI.tag.GridViewTag();
|
|
grid.uify();
|
|
const cb = jest.fn();
|
|
grid.oncellselect = cb;
|
|
grid.onrowselect = cb;
|
|
grid.oncelldbclick = cb;
|
|
const data = get_grid_data();
|
|
const row0 = data.rows[0];
|
|
const row1 = data.rows[1];
|
|
row0[1].selected = true;
|
|
grid.set(data);
|
|
$(row1[0].domel).trigger("click");
|
|
expect(cb).toBeCalledTimes(4);
|
|
expect(grid.selectedCell).toBe(row1[0].domel);
|
|
expect(grid.selectedRow).toBe(row1.domel);
|
|
expect(grid.selectedRows.length).toBe(1);
|
|
grid.multiselect = true;
|
|
$(row0[1].domel).trigger("click");
|
|
expect(cb).toBeCalledTimes(6);
|
|
expect(grid.selectedRows.length).toBe(2);
|
|
$(row0[1].domel).trigger("dblclick");
|
|
expect(cb).toBeCalledTimes(7);
|
|
expect(grid.selectedRows.length).toBe(2);
|
|
});
|
|
|
|
// Treeview
|
|
test("Treeview item setter/getter", () => {
|
|
const item = new OS.GUI.tag.SimpleTreeViewItem();
|
|
item.uify();
|
|
const tdata = get_treedata();
|
|
item.data = tdata;
|
|
expect(item.data).toBe(tdata);
|
|
expect(item.nodes).toBe(tdata.nodes);
|
|
expect(item.open).toBe(false);
|
|
expect(item.indent).toBe(0);
|
|
expect(item.treepath).toBe(item.aid.toString());
|
|
expect(item.parent).toBeUndefined();
|
|
item.update("expand");
|
|
expect(item.open).toBe(true);
|
|
const child = item.nodes[2].domel;
|
|
expect(child.data).toBe(item.nodes[2]);
|
|
expect(child.indent).toBe(1);
|
|
expect(child.open).toBe(true);
|
|
const childtree = $(child).closest("afx-tree-view")[0];
|
|
expect(childtree).toBeDefined();
|
|
expect(child.treepath).toBe(`${item.aid}/${childtree.aid}`);
|
|
expect(child.parent).toBe(childtree);
|
|
child.selected = true;
|
|
expect(child.selected).toBe(true);
|
|
});
|
|
// Treeview
|
|
test("Treeview setter/getter", () => {
|
|
const item = new OS.GUI.tag.TreeViewTag();
|
|
item.uify();
|
|
const tdata = get_treedata();
|
|
item.data = tdata;
|
|
item.expandAll();
|
|
expect(item.selectedItem).toBeUndefined();
|
|
expect(item.data).toBe(tdata);
|
|
expect(item.treeroot).toBeUndefined();
|
|
expect(item.treepath).toBe(item.aid.toString());
|
|
expect(item.indent).toBe(0);
|
|
expect(item.dragndrop).toBe(false);
|
|
expect(item.itemtag).toBe("afx-tree-view-item");
|
|
const child = item.data.nodes[2].domel;
|
|
expect(child).toBeDefined();
|
|
const childtree = $(child).closest("afx-tree-view")[0];
|
|
expect(child.treeroot).toBe(item);
|
|
expect(childtree.is_leaf()).toBe(false);
|
|
});
|
|
test("Treeview behavior", () => {
|
|
const item = new OS.GUI.tag.TreeViewTag();
|
|
item.uify();
|
|
const tdata = get_treedata();
|
|
item.data = tdata;
|
|
item.expandAll();
|
|
const child = item.data.nodes[2].domel;
|
|
const cb = jest.fn();
|
|
item.ontreeselect = cb;
|
|
item.ontreedbclick = cb;
|
|
|
|
$(">div", child).trigger("click");
|
|
expect(cb).toBeCalledTimes(1);
|
|
expect(item.selectedItem).toBe(child);
|
|
const anotherchild = item.data.nodes[1].domel;
|
|
anotherchild.selected = true;
|
|
expect(cb).toBeCalledTimes(2);
|
|
expect(item.selectedItem).toBe(anotherchild);
|
|
expect(child.selected).toBe(false);
|
|
$(">div", child).trigger("dblclick");
|
|
expect(cb).toBeCalledTimes(3);
|
|
expect(item.selectedItem).toBe(child);
|
|
});
|
|
|
|
// Calendar tag
|
|
test("Calendar tag setter/getter", () => {
|
|
const item = new OS.GUI.tag.CalendarTag();
|
|
item.uify();
|
|
const now = {
|
|
d: new Date().getDate(),
|
|
m: new Date().getMonth(),
|
|
y: new Date().getFullYear(),
|
|
};
|
|
expect(item.selectedDate).toStrictEqual(new Date(now.y, now.m, now.d));
|
|
});
|
|
|
|
test("Calendar tag behavior", () => {
|
|
const item = new OS.GUI.tag.CalendarTag();
|
|
const cb = jest.fn();
|
|
item.ondateselect = cb;
|
|
item.uify();
|
|
expect(cb).toBeCalledTimes(1);
|
|
});
|
|
|
|
// File view tag
|
|
|
|
function get_files_data() {
|
|
return JSON.parse(`\
|
|
[{
|
|
"permissions": " (755)",
|
|
"type": "dir",
|
|
"mtime": "2017-07-23T22:53:10",
|
|
"size": 102,
|
|
"path": "home:////desktop",
|
|
"ctime": "2017-07-23T22:53:10",
|
|
"filename": "desktop",
|
|
"perm": {
|
|
"owner": {
|
|
"write": true,
|
|
"read": true,
|
|
"exec": true
|
|
},
|
|
"group": {
|
|
"write": false,
|
|
"read": true,
|
|
"exec": true
|
|
},
|
|
"other": {
|
|
"write": false,
|
|
"read": true,
|
|
"exec": true
|
|
}
|
|
},
|
|
"mime": "",
|
|
"uid": 501,
|
|
"gid": 20
|
|
},
|
|
{
|
|
"permissions": " (644)",
|
|
"type": "file",
|
|
"mtime": "2017-07-30T00:55:34",
|
|
"size": 2821,
|
|
"path": "home:////settings.json",
|
|
"ctime": "2017-07-30T00:55:34",
|
|
"filename": "settings.json",
|
|
"perm": {
|
|
"owner": {
|
|
"write": true,
|
|
"read": true,
|
|
"exec": false
|
|
},
|
|
"group": {
|
|
"write": false,
|
|
"read": true,
|
|
"exec": false
|
|
},
|
|
"other": {
|
|
"write": false,
|
|
"read": true,
|
|
"exec": false
|
|
}
|
|
},
|
|
"mime": "application/json",
|
|
"uid": 501,
|
|
"gid": 20
|
|
},
|
|
{
|
|
"permissions": " (644)",
|
|
"type": "file",
|
|
"mtime": "2017-07-11T20:30:51",
|
|
"size": 575,
|
|
"path": "home:////helloworld.xml",
|
|
"ctime": "2017-07-11T20:30:51",
|
|
"filename": "helloworld.xml",
|
|
"perm": {
|
|
"owner": {
|
|
"write": true,
|
|
"read": true,
|
|
"exec": false
|
|
},
|
|
"group": {
|
|
"write": false,
|
|
"read": true,
|
|
"exec": false
|
|
},
|
|
"other": {
|
|
"write": false,
|
|
"read": true,
|
|
"exec": false
|
|
}
|
|
},
|
|
"mime": "application/xml",
|
|
"uid": 501,
|
|
"gid": 20
|
|
}
|
|
]`);
|
|
}
|
|
test("File view setter/getter", () => {
|
|
const fileview = new OS.GUI.tag.FileViewTag();
|
|
fileview.uify();
|
|
expect(fileview.data.length).toBe(0);
|
|
expect(fileview.status).toBe(true);
|
|
expect(fileview.view).toBe("list");
|
|
expect(fileview.showhidden).toBe(false);
|
|
expect(fileview.chdir).toBe(true);
|
|
fileview.status = false;
|
|
expect(fileview.status).toBe(false);
|
|
fileview.view = "icon";
|
|
expect(fileview.view).toBe("icon");
|
|
fileview.showhidden = true;
|
|
expect(fileview.showhidden).toBe(true);
|
|
fileview.chdir = false;
|
|
expect(fileview.chdir).toBe(false);
|
|
expect(fileview.selectedFile).toBeUndefined();
|
|
fileview.path = "home://";
|
|
expect(fileview.path).toBe("home://");
|
|
const data = get_files_data();
|
|
fileview.data = data;
|
|
expect(fileview.data).toBe(data);
|
|
|
|
});
|
|
|
|
test("File view behavior", () => {
|
|
const fileview = new OS.GUI.tag.FileViewTag();
|
|
fileview.uify();
|
|
fileview.view = "icon";
|
|
const cb = jest.fn();
|
|
fileview.onfileselect = cb;
|
|
fileview.onfileopen = cb;
|
|
const data = get_files_data();
|
|
data[2].selected = true;
|
|
fileview.data = data;
|
|
expect(cb).toBeCalledTimes(1);
|
|
const el = fileview.selectedFile;
|
|
expect(el).toBe(data[2]);
|
|
$("li", el.domel).trigger("dblclick");
|
|
expect(cb).toBeCalledTimes(2);
|
|
/* fileview.view = "tree";
|
|
fileview.update("expand");
|
|
const treeitem = fileview.data[0].domel;
|
|
expect(treeitem.tagName).toBe("AFX-TREE-VIEW-ITEM"); */
|
|
});
|