pyseext 2.0.1__tar.gz → 2.0.2__tar.gz

{pyseext-2.0.1/src/pyseext.egg-info → pyseext-2.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyseext
-Version: 2.0.1
+Version: 2.0.2
 Summary: Aids the testing of ExtJS applications from Python using Selenium.
 Home-page: https://github.com/westy/pyseext
 Author: Martyn West

{pyseext-2.0.1 → pyseext-2.0.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pyseext"
-version = "2.0.1"
+version = "2.0.2"
 description = "Aids the testing of ExtJS applications from Python using Selenium."
 readme = "README.md"
 requires-python = ">=3.8"

pyseext-2.0.2/src/pyseext/js/PySeExt.ComponentQuery.js

@@ -0,0 +1,123 @@
+globalThis.None = null;
+
+globalThis.PySeExt = globalThis.PySeExt || {};
+globalThis.PySeExt.ComponentQuery = {
+    /**
+     * Returns an array of matched element dom objects from within the dom.
+     *
+     * This wraps Ext.ComponentQuery.query, so see there for more detail.
+     * Each component has it's dom object returned however.
+     * You should never need this from Ext code. This will likely be useful for automated testing.
+     *
+     * Only supports the passing in of a single root (so no filtering), and an optional CSS selector,
+     * to return a sub-element in the found component.
+     *
+     * @param {String} selector      The selector string to filter returned elements.
+     * @param {String} [rootId]      The id of the dom element indicating the container within which to perform the query.
+     *                               If omitted, all components within the document are included in the search.
+     * @param {String} [cssSelector] An optional CSS selector that can be used to get child elements of a found component, e.g. a trigger on a field.
+     * @return {Object[]}            The matched dom objects or an empty array if none found.
+     */
+    query: function(selector, rootId, cssSelector) {
+        var components,
+            results = [],
+            root,
+            len,
+            i,
+            component,
+            el,
+            j;
+
+        // Get component for our root if specified
+        if (rootId) {
+            root = globalThis.Ext.getCmp(rootId);
+
+            if (!root) {
+                globalThis.Ext.Error.raise("Failed to find root component with id '" + rootId + "'! Are you passing in WebElement.get_attribute('id'), because that's what you need?");
+            }
+        }
+
+        components = globalThis.Ext.ComponentQuery.query(selector, root);
+        len = components && components.length;
+
+        if (len) {
+            for (i = 0; i < len; i += 1) {
+                component = components[i];
+
+                if (component && component.getEl) {
+                    el = component.getEl();
+
+                    if (el) {
+                        if (cssSelector) {
+                            el = el.query(cssSelector);
+
+                            if (el && el.length) {
+                                for (j = 0; j < el.length; j += 1) {
+                                    if (el[j]) {
+                                        // This will already be a DOM element,
+                                        // since Element.query defaults to that.
+                                        results.push(el[j]);
+                                    }
+                                }
+                            }
+                        } else {
+                            results.push(el.dom);
+                        }
+                    }
+                }
+            }
+        }
+
+        return results;
+    },
+
+    /**
+     * Determines whether all components for the specified CQ are an instance of the specified class name.
+     *
+     * Note, will return True if the components are a subclass of the type too.
+     * @param {String} className The name of the class that we want to test for.
+     * @param {String} selector The selector string to query for.
+     * @param {String} rootId The id of the dom element indicating the container within which to perform the query.
+     *                        If omitted, all components within the document are included in the search.
+     * @return {Boolean} True if all components are an instance of the specified class, False if they are not, and
+     *                   undefined if no components are found.
+     */
+    isComponentInstanceOf: function(className, selector, rootId) {
+        var cls = Ext.ClassManager.get(className),
+            components,
+            root,
+            len,
+            i,
+            component,
+            el,
+            isInstance;
+
+        if (!cls) {
+            globalThis.Ext.Error.raise("A class with the name '" + className + "' is not defined!");
+        }
+
+        // Get component for our root if specified
+        if (rootId) {
+            root = globalThis.Ext.getCmp(rootId);
+        }
+
+        components = globalThis.Ext.ComponentQuery.query(selector, root);
+        len = components && components.length;
+
+        if (len) {
+            for (i = 0; i < len; i += 1) {
+                component = components[i];
+
+                if (component) {
+                    isInstance = component instanceof cls;
+
+                    if (!isInstance) {
+                        break;
+                    }
+                }
+            }
+        }
+
+        return isInstance;
+    }
+};

pyseext-2.0.2/src/pyseext/js/PySeExt.Core.js

@@ -0,0 +1,34 @@
+globalThis.None = null;
+
+globalThis.PySeExt = globalThis.PySeExt || {};
+globalThis.PySeExt.Core = {
+    /**
+     * Retrieves the value of a member from an object.
+     *
+     * The member can contain periods, to access child objects.
+     *
+     * @param  {Object} object The object from which to retrieve the value.
+     * @param  {String} member A string identifying the member value to retrieve. Can contain periods to access child objects.
+     * @return {Object} The value of the object member, or undefined if it or any part of the path was not found.
+     */
+    getObjectMember: function(object, member) {
+        var me = this,
+            members = member.split('.'),
+            value = object[members[0]];
+
+        if (value && (members.length > 1)) {
+            members.shift();
+            value = me.getObjectMember(value, members.join('.'));
+        }
+
+        return value;
+    },
+
+    /**
+     * Indicates whether there is currently an Ajax request in progress.
+     * @return {Boolean} True if there is a request in progress, false otherwise.
+     */
+    isAjaxRequestInProgress: function() {
+        return globalThis.Ext.Ajax.isLoading();
+    }
+};

pyseext-2.0.2/src/pyseext/js/PySeExt.FieldHelper.js

@@ -0,0 +1,249 @@
+globalThis.None = null;
+
+globalThis.PySeExt = globalThis.PySeExt || {};
+globalThis.PySeExt.FieldHelper = {
+    /**
+     * Finds the specified field input element on the specified form.
+     * @param {String} formCQ The CQ to get to the form panel.
+     * @param {String} name The name of the field.
+     * @returns The DOM for the field's input element
+     */
+    findFieldInputElement: function(formCQ, name) {
+        var field = this.__getField(formCQ, name);
+
+        return field && field.inputEl.dom;
+    },
+
+    /**
+     * Finds the specified field on the specified form and returns it's xtype.
+     * @param {String} formCQ The CQ to get to the form panel.
+     * @param {String} name The name of the field.
+     * @returns {String} The xtype of the field, if found.
+     */
+    getFieldXType: function(formCQ, name) {
+        var field = this.__getField(formCQ, name);
+
+        return field && field.xtype;
+    },
+
+    /**
+     * Finds the specified field on the specified form and returns it's value.
+     * @param {String} formCQ The CQ to get to the form panel.
+     * @param {String} name The name of the field.
+     * @returns {Mixed} The value of the field, if found.
+     */
+    getFieldValue: function(formCQ, name) {
+        var field = this.__getField(formCQ, name),
+            value;
+
+        if (field) {
+            value = field.getValue();
+            // Python cannot convert a JS datetime to a Python one, so convert before sending.
+            if (Ext.isDate(value)) {
+                value = value.toLocaleDateString('en-gb')
+            }
+        }
+
+        return value;
+    },
+
+    /**
+     * Finds the specified field on the specified form and returns it's display value, if it has one.
+     * @param {String} formCQ The CQ to get to the form panel.
+     * @param {String} name The name of the field.
+     * @returns {Mixed} The display value of the field, if found and has a display value.
+     */
+    getFieldDisplayValue: function(formCQ, name) {
+        var field = this.__getField(formCQ, name);
+
+        return field && field.getDisplayValue && field.getDisplayValue();
+    },
+
+    /**
+     * Finds the specified field on the specified form and returns it's raw value, if it has one.
+     * @param {String} formCQ The CQ to get to the form panel.
+     * @param {String} name The name of the field.
+     * @returns {String} The raw value of the field, if found and has a raw value.
+     */
+    getFieldRawValue: function(formCQ, name) {
+        var field = this.__getField(formCQ, name);
+
+        return field && field.getRawValue && field.getRawValue();
+    },
+
+    /**
+     * Finds the specified field and sets its value directly.
+     *
+     * Raises an error if the field was not found.
+     * @param {String} formCQ The CQ to get to the form panel.
+     * @param {String} name The name of the field.
+     * @param {Number} value The value of the field.
+     */
+    setFieldValue: function(formCQ, name, value) {
+        this.__getField(formCQ, name, true).setValue(value);
+    },
+
+    /**
+     * Determines whether the specified field is a remotely filtered combobox.
+     * @param {String} formCQ The CQ to get to the form panel.
+     * @param {String} name The name of the field.
+     * @returns {Boolean} True if the field was found, and is a remotely filtered combobox.
+     *                    False otherwise.
+     */
+    isRemotelyFilteredComboBox: function(formCQ, name) {
+        var field = this.__getField(formCQ, name),
+            isRemotelyFilteredComboBox;
+
+        isRemotelyFilteredComboBox = field instanceof globalThis.Ext.form.field.ComboBox &&
+                                     field.queryMode === 'remote';
+
+        return isRemotelyFilteredComboBox;
+    },
+
+    /**
+     * Method to focus on a field on a form by (zero-based) index or name.
+     *
+     * Raises an error if the field was not found.
+     * @param {String} formCQ The CQ to get to the form panel.
+     * @param {String|Integer} indexOrName The zero-based index or name of the field to focus.
+     */
+    focusField: function(formCQ, indexOrName) {
+        var me = this;
+
+        if (globalThis.Ext.isString(indexOrName)) {
+            me.__getField(formCQ, indexOrName, true).focus();
+        } else {
+            me.__getFieldAtIndex(formCQ, indexOrName).focus();
+        }
+    },
+
+    /**
+     * Determines whether the specified field has focus or not.
+     *
+     * @param {String} formCQ The CQ to get to the form panel.
+     * @param {String|Integer} indexOrName The zero-based index or name of the field to focus.
+     * @returns {Boolean} True if the field has focus, false otherwise.
+     */
+    doesFieldHaveFocus: function(formCQ, indexOrName) {
+        var me = this,
+            field;
+
+        if (globalThis.Ext.isString(indexOrName)) {
+            field = me.__getField(formCQ, indexOrName, true);
+        } else {
+            field = me.__getFieldAtIndex(formCQ, indexOrName);
+        }
+
+        return field.hasFocus;
+    },
+
+    /**
+     * Selects a value on a combobox field by finding a record with the specified data.
+     *
+     * Ensures that the select event is fired if the record is found and selected.
+     * @param {String} formCQ The CQ to get to the form panel.
+     * @param {String} name The name of the field.
+     * @param {Object} data The data to find in the combobox store and select.
+     * @returns {Boolean} Indicates whether a record was found and selected.
+     */
+    selectComboBoxValue: function(formCQ, name, data) {
+        var me = this,
+            field = me.__getField(formCQ, name, true),
+            store,
+            index,
+            record;
+
+        if (field instanceof globalThis.Ext.form.field.ComboBox) {
+            store = field.getStore();
+
+            if (store.isLoaded()) {
+                index = store.getData().findIndexBy(function(record) {
+                    var prop,
+                        doAllMembersMatch = true;
+
+                    for (prop in data) {
+                        if (data.hasOwnProperty(prop)) {
+                            if (data[prop] !== record.get(prop)) {
+                                doAllMembersMatch = false;
+                                break;
+                            }
+                        }
+                    }
+
+                    return doAllMembersMatch;
+                });
+
+                if (index === -1) {
+                    // Record was not found
+                    return false;
+                } else {
+                    record = store.getAt(index);
+
+                    field.select(record);
+                    field.fireEvent('select', field, record);
+
+                    return true;
+                }
+            } else {
+                globalThis.Ext.Error.raise("The combobox store is not loaded!");
+            }
+        } else {
+            globalThis.Ext.Error.raise("Field is not a combobox!");
+        }
+    },
+
+    /**
+     * Finds a field in a form panel.
+     * Optionally raises an error if not found.
+     * @param {String} formCQ The CQ to get to the form panel.
+     * @param {String} name The name of the field.
+     * @param {Boolean} throwIfNotFound Indicates whether to raise an error if not found.
+     *                                  If omitted then value is taken to be false.
+     * @returns {Ext.form.field.Base} The field instance.
+     */
+    __getField: function(formCQ, name, throwIfNotFound) {
+        var formPanel = Ext.ComponentQuery.query(formCQ),
+            field;
+
+        if (formPanel && formPanel.length) {
+            formPanel = formPanel[0];
+            field = formPanel.getForm().findField(name);
+        } else if (throwIfNotFound) {
+            globalThis.Ext.Error.raise("Form panel could not be found!");
+        }
+
+        if (!field && throwIfNotFound) {
+            globalThis.Ext.Error.raise("Field could not be found!");
+        }
+
+        return field;
+    },
+
+    /**
+     * Gets a field in a form panel by index.
+     *
+     * Raises an error if the index is outside of the bounds of the fields,
+     * or is otherwise invalid.
+     * @param {String} formCQ The CQ to get to the form panel.
+     * @param {Number} index The index of the field.
+     * @returns {Ext.form.field.Base} The field instance.
+     */
+     __getFieldAtIndex: function(formCQ, index) {
+        var formPanel = Ext.ComponentQuery.query(formCQ),
+            field;
+
+        if (formPanel && formPanel.length) {
+            formPanel = formPanel[0];
+            field = formPanel.getForm().getFields().getAt(index);
+        } else {
+            globalThis.Ext.Error.raise("Form panel could not be found!");
+        }
+
+        if (!field) {
+            globalThis.Ext.Error.raise("Field could not be found!");
+        }
+
+        return field;
+    }
+
+};

pyseext-2.0.2/src/pyseext/js/PySeExt.GridHelper.js

@@ -0,0 +1,249 @@
+globalThis.None = null;
+
+globalThis.PySeExt = globalThis.PySeExt || {};
+globalThis.PySeExt.GridHelper = {
+    /**
+     * Gets the element for a column header on the specified grid, by header text or dataIndex.
+     * @param {String} gridSelector The CQ for the grid
+     * @param {String} columnTextOrDataIndex The text or dataIndex of the column
+     * @returns {Object} The DOM node for the column header
+     */
+    getColumnHeader: function(gridSelector, columnTextOrDataIndex) {
+        var me = this,
+            columnHeader = me.__findColumnHeader(gridSelector, columnTextOrDataIndex);
+
+        return columnHeader && columnHeader.getEl().dom;
+    },
+
+    /**
+     * Gets the element for a column header's trigger on the specified grid, by header text or dataIndex.
+     * @param {String} gridSelector The CQ for the grid
+     * @param {String} columnTextOrDataIndex The text or dataIndex of the column
+     * @returns {Object} The DOM node for the column header's trigger
+     */
+     getColumnHeaderTrigger: function(gridSelector, columnTextOrDataIndex) {
+        var me = this,
+            columnHeader = me.__findColumnHeader(gridSelector, columnTextOrDataIndex),
+            columnHeaderTrigger;
+
+        if (columnHeader) {
+            columnHeaderTrigger = columnHeader.getEl().down('.x-column-header-trigger', true);
+        }
+
+        return columnHeaderTrigger;
+    },
+
+    /**
+     * Clears the current selection.
+     *
+     * Useful if want to quickly refresh a grid without having to process all the events.
+     * This will only work if the grid supports deselection.
+     *
+     * @param  {String}   gridSelector The selector for the grid.
+     * @return {void}
+     */
+    clearSelection: function(gridSelector) {
+        var grids = globalThis.Ext.ComponentQuery.query(gridSelector);
+
+        if (grids && grids.length) {
+            grids[0].getSelectionModel().deselectAll();
+        }
+    },
+
+    /**
+     * Gets the row element with the specified data or index in the grid.
+     * The row is scrolled into view ready for clicking by the caller.
+     *
+     * The grid must be visible.
+     *
+     * @param  {String}        gridSelector The selector for the grid.
+     * @param  {Object|Number} rowData      The index of or an object containing the row data for the record to be found.
+     * @return {Element} The element for the found row.
+     */
+    getRow: function(gridSelector, rowData) {
+        var me = this,
+            grids = globalThis.Ext.ComponentQuery.query(gridSelector),
+            grid,
+            store,
+            rowIndex;
+
+        if (grids && grids.length) {
+            grid = grids[0];
+            store = grid.getStore();
+
+            rowIndex = me.__findRowIndex(rowData, store);
+
+            if (rowIndex !== -1) {
+                return grid.getView().getRow(rowIndex);
+            }
+        }
+        
+        return null;
+    },
+
+    /**
+     * Gets the row data with the specified data or index in the grid.
+     * The row is scrolled into view ready for clicking by the caller.
+     *
+     * The grid must be visible.
+     *
+     * @param  {String} gridSelector   The selector for the grid.
+     * @param  {Object|Number} rowData The index of or an object containing the row data for the record to be found.
+     * @return {Object[]} The data for the found row.
+     */
+    getRowData: function(gridSelector, rowData) {
+        var me = this,
+            grids = globalThis.Ext.ComponentQuery.query(gridSelector),
+            grid,
+            store,
+            rowIndex;
+
+        if (grids && grids.length) {
+            grid = grids[0];
+            store = grid.getStore();
+
+            rowIndex = me.__findRowIndex(rowData, store);
+
+            if (rowIndex !== -1) {
+                var data = store.getAt(rowIndex).getData();
+                var converted = {};
+                Object.keys(data).forEach(function (key) {
+                    var value = data[key];
+                    if (value instanceof Date) {
+                        // Convert to ISO 8601 string, which Python can parse easily
+                        converted[key] = value.toLocaleString("en-GB", { timeZone: "Europe/London" });
+                    } else {
+                        converted[key] = value;
+                    }
+                });
+
+                return converted;
+            }
+        }
+
+        return null;
+    },
+
+    /**
+     * Trims the specified row data to contain just the required fields.
+     *
+     * Useful when we have stored some row data, and want to select it again later, but some of the ids of times
+     * may be different.
+     *
+     * @param  {Object} rowData        The row data to trim.
+     * @param  {Array}  requiredFields An array of string indicating the fields that are required from the row data.
+     * @return {Object} A copy of the row data object, with only the required fields included.
+     */
+    __trimRowData: function(rowData, requiredFields) {
+        var trimmedRowData = {},
+            i;
+
+        for (i = 0; i < requiredFields.length; i += 1) {
+            trimmedRowData[requiredFields[i]] = rowData[requiredFields[i]];
+        }
+
+        return trimmedRowData;
+    },
+
+    /**
+     * Retrieves the selection of the specified grid.
+     * @private
+     * @param  {String}         gridSelector       The selector for the grid.
+     * @param  {Function}       callback           The function to call when the done.
+     * @param  {Array}          callback.selection The grids current selection.
+     * @return {void}
+     */
+    __getSelection: function(gridSelector, callback) {
+        var grids = globalThis.Ext.ComponentQuery.query(gridSelector);
+
+        if (grids && grids.length) {
+            globalThis.Ext.callback(callback, this, [grids[0].getSelectionModel().getSelection()]);
+        }
+    },
+
+    /**
+     * Finds on a column header on a grid.
+     * @private
+     * @param  {String} gridSelector          The selector for the grid.
+     * @param  {String} columnTextOrDataIndex The text or dataIndex of the column to find.
+     * @return {Ext.Component}                The column header component
+     */
+     __findColumnHeader: function(gridSelector, columnTextOrDataIndex) {
+        var me = this,
+            grid,
+            dataColumns,
+            i,
+            dataColumn,
+            columnHeader;
+
+        components = Ext.ComponentQuery.query(gridSelector);
+        if (components && components.length) {
+            grid = components[0];
+
+            dataColumns = grid.headerCt.gridDataColumns
+
+            // Find column header
+            for (i = 0; i < dataColumns.length; i += 1) {
+                dataColumn = dataColumns[i];
+
+                if ((dataColumn.dataIndex === columnTextOrDataIndex) ||
+                    (dataColumn.text === columnTextOrDataIndex)) {
+
+                    columnHeader = dataColumn;
+                    break;
+                }
+            }
+        }
+
+        return columnHeader;
+    },
+
+    /**
+     * Gets the row index with the specified data or index in the grid.
+     * The row is scrolled into view ready for clicking by the caller.
+     *
+     * The grid must be visible.
+     *
+     * @param  {Object|Number} rowData The index of or an object containing the row data for the record to be found.
+     * @return {Number} The index for the row record, or -1 if not found
+     */
+    __findRowIndex: function(rowData, store) {
+        var rowIndex = -1,
+            foundIndex,
+            prop;
+
+        if (typeof(rowData) === 'number') {
+            foundIndex = rowData;
+
+            // Verify it's not bollocks
+            if (!Ext.isNumber(parseInt(foundIndex)) || foundIndex < 0) {
+                globalThis.Ext.raise('If attempting to get a row for a specific index, the index must be an integer greater than or equal to zero.');
+            }
+
+            // Check that found index is within bounds, if so grab the row.
+            if (foundIndex < store.getCount()) {
+                rowIndex = foundIndex;
+            }
+        } else {
+            foundIndex = store.findBy(function(record, id) {
+                var hasRecordBeenFound = true;
+
+                for (prop in rowData) {
+                    if (rowData.hasOwnProperty(prop)) {
+                        if (record.get(prop) !== rowData[prop]) {
+                            hasRecordBeenFound = false;
+                            break;
+                        }
+                    }
+                }
+
+                return hasRecordBeenFound;
+            });
+
+            // This could be -1, but that's fine since that's the expected "not found" result.
+            rowIndex = foundIndex;
+        }
+
+        return rowIndex;
+    }
+};