@peter.naydenov/shortcuts 3.3.1 → 3.5.0

package/test/01-general.test.js

@@ -1,37 +1,52 @@
-import { beforeEach, describe, it, test } from 'vitest'
+import { beforeEach, afterEach, describe, it, expect } from 'vitest'
 import { userEvent } from '@vitest/browser/context'
+import {
+  getByLabelText,
+  getByText,
+  getByTestId,
+  queryByTestId,
+  // Tip: all queries are also exposed on an object
+  // called "queries" which you could import here as well
+  waitFor
+} from '@testing-library/dom'
+
 
-import Block from '../test-components/Block.jsx'
-import VisaulController from '@peter.naydenov/visual-controller-for-react'
-import '../test-components/style.css'
 
+import '../test-helpers/style.css'
+import Block from '../test-helpers/Block.jsx'
+import VisaulController from '@peter.naydenov/visual-controller-for-react'
+import wait             from '../test-helpers/wait.js'
 import { 
           pluginClick,
           pluginKey
         , pluginForm
         , shortcuts 
                 } from '../src/main.js'
-import { expect } from 'chai'
+
 
 import askForPromise from 'ask-for-promise'
 
 const html = new VisaulController ();
-
 let
        a = false
      , b = false
+     , c = null
      ;
-
-
-function wait (ms) {
-        return new Promise((resolve) => setTimeout(resolve, ms));
-      }
-                                    
-const short = shortcuts ({onShortcut : ( shortcut, {context,note,type}) =>  console.log (shortcut, context, note, type)   });
-    
-short.load ({
+const contextDefinition = {
                   general : {
-                            ' key : shift+a': [ () => a = true ]
+                            ' key : shift+a': [ 
+                                        () => a = true, 
+                                        () => c = 'triggered' 
+                                      ],
+                            '@shortcuts-error' : ( m ) =>  c = m
+                        }
+                , touch : {
+                              // Single click with left button
+                              'click: left-1': () => b = true,
+                              // Double click with left button
+                              'click: left-2': () => b = true,
+                              // Single click with right button
+                              'click: right-1': () => b = true
                         }
                 , extra : {    
                             'key : p,r,o,b,a': () => b = true                        
@@ -47,253 +62,145 @@ short.load ({
                                 }
                             ]
                     }
-        })
-
-beforeEach ( () => {
-    let container = document.createElement ( 'div' )
-    container.id = 'app'
-    document.body.appendChild ( container )
-    html.publish ( Block, {}, 'app' )
-    a = false, b = false
-}) // beforeEach
+      }
 
 
+                                    
+let short = shortcuts ();
 
 
 
 describe ( "Shortcuts", () => {
 
+        beforeEach ( async  () => {
+                        short.load ( contextDefinition )
+                        let container = document.createElement ( 'div' )
+                        container.id = 'app'
+                        document.body.appendChild ( container )
+                        await html.publish ( Block, {}, 'app' )
+                        a = false, b = false
+            }) // beforeEach
 
 
-test ( 'Shortcut if no plugin installed', () => {
-            let res = new Promise ( (resolve,reject) => {
-                            short.changeContext ( 'general' )
-                            let r = short.listShortcuts ('general')
-                            expect ( r[0]).to.equal ( ' key : shift+a' ) // Shortcut name is the same as it was set
-                            resolve ('success')
-                })
-            return res
-    }) // test no plugin installed
-
-
-
-test ( 'Key plugin, no context selected', () => {
-            const res = new Promise ( ( resolve ) => {
-                        short.enablePlugin ( pluginKey )
-                        const r = short.listShortcuts ( 'general' )
-                        expect ( r[0] ).to.equal ( 'KEY:A+SHIFT' ) // Shortcut name is recognized by plugin and is normalized
-                        resolve ('success')
-                })
-            return res
-    }) // test key plugin installed, no context selected
-
-
-
-test ( 'Key plugin with context selected', () => {
-            const res = new Promise ( (resolve) => {
-                        short.enablePlugin ( pluginKey )
-                        short.changeContext ( 'general' )
-                        const r = short.listShortcuts ('general')
-                        expect ( r[0] ).to.equal ( 'KEY:A+SHIFT' ) // Shortcut name is recognized by plugin and is normalized
-                        resolve ( 'success' )
-                    })
-            return res
-    }) // test key plugin installed with context selected
-
-
-
-test ( 'Simple shortcut', () => {
-            const res = new Promise ( (resolve) => {
-                                    short.enablePlugin ( pluginKey )
-                                    short.changeContext ()
-                                    short.changeContext ( 'general'  )
-                                    userEvent.keyboard ( '{Shift>}a</Shift>' )
-                                    expect ( a ).to.be.false
-                                    wait ( 1000 ) 
-                                       .then ( () => { // Default wait sequence timeout is 480 ms, but maxSequence is 1, so we don't need to wait for timeout
-                                                expect ( a ).to.be.true 
-                                                resolve ( 'success' )
-                                       })
-                            })
-            return res
-    }) // test simple shortcut
-
-
-
-test ( 'Call sequence shortcut', async () => {
-        let res = new Promise ( async (resolve) => {
-                            b = false
-                            short.enablePlugin ( pluginKey )
-                            short.changeContext ()
-                            short.changeContext ( 'extra' )
-                            await userEvent.keyboard ( 'proba' )
-                            expect ( b ).to.be.true
-                            resolve ( 'success' )
-                    })
-        return res
-    }) // test call sequence shortcut
-
-
-
-test ( 'Single mouse click', done => {
-        const res = new Promise ( async (resolve) => {
-                                expect ( a ).to.be.false
-                                expect ( b ).to.be.false
-                                short.enablePlugin ( pluginClick )
-                                
-                                short.load ({ 'extra' : { 
-                                                        ' cLIck  : left - 1 ' : () => a = true   // Check if spaces, letter case can break the shortcut recognition
-                                                    }
-                                        })
-                                short.changeContext ()
-                                short.changeContext ( 'extra' )
-                                wait ( 100 )
-                                   .then ( async () => {
-                                            // Default wait mouse timeout is 320 ms, but maxClicks is 1, so we don't need to wait for timeout
-                                            let loc = document.querySelector('#rspan')  || false 
-                                            if ( loc )   await userEvent.click ( loc )
-                                            expect ( a ).to.be.true 
-                                            resolve ( 'success' ) 
-                                        })
-                                
-                                
-                        })
-        return res
-    }) // test single mouse click
-
-
-
-test ( 'Double mouse click', () => {
-        let res = new Promise ( async (resolve) => {
-                                    expect ( a ).to.be.false
-                                    expect ( b ).to.be.false
-
-                                    short.enablePlugin ( pluginClick )
-                                    short.changeContext ( 'extra' )
-                                    short.load ({ // load will restart the selected context
-                                                    'extra' : {   // load will overwrite existing 'extra' context definition
-                                                                'click: left-2' : () => a = true
-                                                            } 
-                                                }) 
-                                    wait ( 350 )
-                                        .then ( async () => {   // Default wait mouse timeout is 320 ms
-                                            let loc = document.querySelector ( '#rspan' )  || false
-                                            // Third click is ignored. Max clicks according definition is 2.
-                                            if ( loc )   await userEvent.tripleClick ( loc )
-                                            expect ( a ).to.be.true
-                                            resolve ( 'success' )
-                                        })
-                    })
-        return res
-    }) // test double mouse click
-
-
-
-test ( 'Dependencies on shortcuts', () => {
-        const res = new Promise ( async (resolve) => {
-                            const task = askForPromise ();
-                            expect ( a ).to.be.false
-                            expect ( b ).to.be.false
 
-                            short.enablePlugin ( pluginClick )
-                            short.setDependencies ({ task })
-                            
-                            short.load ({   
-                                            'extra' : {   // load will overwrite existing 'extra' context definition
-                                                        'click: left-1' : ({dependencies}) => {
-                                                                                            const { task } = dependencies;
-                                                                                            expect ( task ).to.have.property ( 'done' )
-                                                                                            expect ( task ).to.have.property ( 'promise' )
-                                                                                            a = true
-                                                                                        }
-                                                    } 
-                                        }) // load will restart the selected context
-                            short.changeContext ( 'extra' )
-                            wait ( 350 )   // Default wait mouse timeout is 320 ms
-                                .then ( async () => {
-                                        let loc = document.querySelector ( '#rspan' )  || false
-                                        if ( loc )   await userEvent.click ( loc )
-                                        resolve ( 'success' )
-                                })
-                    }) // res promise
-        return res
-    }) // test dependencies on shortcuts
-
-
-
-test ( 'Emit custom event', () => {
-        const res = new Promise ( async (resolve) => {
-                                let result = null;
-                                short.changeContext ()
-                                short.enablePlugin ( pluginClick )
-                                const myAllContext = { 
-                                                        myAll: {
-                                                                'click : leff-1' : () =>  console.log ( 'nothing' )
-                                                                , 'yo' : ({msg}) => result = msg
-                                                            }}
-                                short.load ( myAllContext )
-                                short.changeContext ( 'myAll' )    
-                                short.emit ( 'yo', { context: short.getContext(), note: 'tt', type:'custom', msg:'hello' })
-                                expect ( result ).to.be.equal ( 'hello' )
-                                short.changeContext ( 'general' )
-                                short.unload ( 'myAll' )
-                                resolve ( 'success' )
-                        })
-        return res
-    }) // test emit custom event
-
-
-
-test ( 'List shortcuts', () => {
-        short.enablePlugin ( pluginKey )
-        let general =  short.listShortcuts ('general');
-        expect ( general ).to.be.an ( 'array' )
-        expect ( general ).to.have.lengthOf ( 1 )
-        expect ( general[0] ).to.be.equal ( 'KEY:A+SHIFT' )
+        afterEach ( async  () => {
+                    short.reset ()
+                    a = false, b = false, c = null;
+            }) // afterEach
+
+
+
+        it ( 'Load and unload context', async () => {
+                      let ls = short.listContexts ()
+                      expect ( ls ).to.includes ( 'general' )
+
+                      short.changeContext ( 'general' )
+                      // Can't not to unload current active context - sends an error on @shortcuts-error
+                      // @shortcuts-error is a system error event used accross the library
+                      short.unload ( 'general' )
+                      expect ( c ).to.be.equal ( `Context 'general' can't be removed during is current active context. Change the context first` )
+                      
+                      // Try to change context to non-existent one
+                      // Message goes to @shortcuts-error                   
+                      short.changeContext ( 'hhm' )
+                      expect ( c ).to.be.equal ( `Context 'hhm' does not exist` )
+
+                      // Change to something that exists
+                      short.changeContext ( 'extra' )
+                      // Free to unload 'general'
+                      short.unload ( 'general' )
+                      ls = short.listContexts ()
+                      // Unload success
+                      expect ( ls ).to.not.includes ( 'general' )
+            }) // it load and unload context
+
+
+        
+        it ( 'List enabled plugins. Disable and enable plugins', async () => {
+                     expect ( short.listPlugins () ).to.be.deep.equal ( [] )
+                     // Enable list of plugins
+                     let myPlugins = [ pluginKey, pluginClick ]
+                     myPlugins.forEach ( plugin =>  short.enablePlugin ( plugin )   )
+                     expect ( short.listPlugins () ).to.be.deep.equal ( [ 'key', 'click' ] )
+                     // Method disablePlugin require plugin name (prefix)
+                     short.disablePlugin ( 'click' )
+                     expect ( short.listPlugins () ).to.be.deep.equal ( [ 'key' ] )
+                     // Method enablePlugin require the plugin as a function
+                     short.enablePlugin ( pluginClick )
+                     expect ( short.listPlugins () ).to.be.deep.equal ( [ 'key', 'click' ] )
+            }) // it list enabled plugins
+
+
+
+        it ( 'Unload non existing context', () => {
+                      let change = false;
+                      let ls = short.listContexts ()
+                      short.load ( {
+                              local : {
+                                      'click : leff-1' : () => console.log ( 'nothing' ),
+                                      '@shortcuts-error': () => change = true
+                                  }
+                          })
+                      short.changeContext ( 'local' )
+                      short.unload ( 'unknown' )
+                      expect ( change ).to.be.true
+            }) // it unload non existing context
+        
         
-        let fail = short.listShortcuts ( 'somethingNotExisting' );
-        expect ( fail ).to.be.null
-    
-        let all = short.listShortcuts ();
-        expect ( all ).to.be.an ( 'array' )
         
-        expect ( all ).to.have.lengthOf ( 3 )
-        expect ( all[0] ).to.have.property ( 'context' )
-        expect ( all[0] ).to.have.property ( 'shortcuts' )
-        expect ( all[0].shortcuts ).to.be.an('array')
-        expect ( all[0].shortcuts ).to.have.lengthOf ( 1 )
-        expect ( all[0].shortcuts[0] ).to.be.equal ( 'KEY:A+SHIFT' )
-        expect ( all[0].context ).to.be.equal ( 'general' )
-    }) // test list shortcuts
-
-
-
-test ( 'Click on anchor', () => {
-        const res = new Promise ( async (resolve) => {
-                                // Click on anchor that don't have click-data attribute.
-                                let result = 'none';
-                                short.enablePlugin ( pluginClick )
-                                short.load ({ 'extra' : { 
-                                                        'click: 1 - left' : ({target, context, event }) => {   // Order of button name and number of click is not important
-                                                                    event.preventDefault ()
-                                                                    expect ( context ).to.be.equal ( 'extra' )
-                                                                    expect ( target.nodeName ).to.be.equal ( 'A' )
-                                                                    result = target.nodeName
-                                                                }
-                                                    } 
-                                        })
-                                short.changeContext ( 'extra' )
-                                wait ( 10 )
-                                    .then ( async () => {
-                                            let loc = document.querySelector ( '#anchor' )  || false;
-                                            if ( loc )   await userEvent.click ( loc )
-                                            expect ( result ).to.be.equal ( 'A' )  
-                                            short.changeContext ( 'general' )
-                                            resolve ( 'success' )
-                                        })
-                        })
-        return res
-    }) // test click on anchor
+        it ( 'Emit custom event', () => {
+                            // TODO: Check arguments for the custom event handlers
+                            let result = null;
+                            short.enablePlugin ( pluginClick )
+                            const myAllContext = { 
+                                                    myAll: {
+                                                            'click : leff-1' : () =>  console.log ( 'nothing' )
+                                                            , 'yo' : ({msg}) => result = msg
+                                                        }}
+                            short.load ( myAllContext )
+                            short.changeContext ( 'myAll' )    
+                            short.emit ( 'yo', { context: short.getContext(), note: 'tt', type:'custom', msg:'hello' })
+                            expect ( result ).to.be.equal ( 'hello' )
+                            short.changeContext ( 'general' )
+                            short.unload ( 'myAll' )
+            }) // it emit custom event
+
+
+
+        it ( 'List shortcuts', () => {
+                      short.enablePlugin ( pluginKey )
+
+                      let general =  short.listShortcuts ('general');
+                      expect ( general ).to.be.an ( 'array' )
+                      expect ( general ).to.have.lengthOf ( 2 )
+                      expect ( general ).to.include ( 'KEY:A+SHIFT' )
+                      
+                      let fail = short.listShortcuts ( 'somethingNotExisting' );
+                      expect ( fail ).to.be.null
+                  
+                      let all = short.listShortcuts ();
+                      expect ( all ).to.be.an ( 'array' )
+                   
+                      expect ( all ).to.have.lengthOf ( 4 )
+                      // Property 'context' is a context name - string
+                      expect ( all[0] ).to.have.property ( 'context' )
+                      expect ( all[0] ).to.have.property ( 'shortcuts' )
+                      expect ( all[0].shortcuts ).to.be.an ( 'array' )
+                      expect ( all[0].shortcuts ).to.have.lengthOf ( 2 )
+                      expect ( all[0].shortcuts ).to.include ( 'KEY:A+SHIFT' )
+                      expect ( all[0].context ).to.be.equal ( 'general' )
+            }) // it list shortcuts
+
+
+
+        it ( 'Reset', () => {
+                      short.enablePlugin ( pluginKey )
+                      short.reset ()
+                      expect ( short.listShortcuts () ).to.have.lengthOf ( 0 )
+                      expect ( short.listShortcuts () ).to.have.lengthOf ( 0 )
+                      expect ( short.getContext () ).to.be.null
+            }) // it Reset
+        
 
 }) // describe