Jforrester has uploaded a new change for review. ( 
https://gerrit.wikimedia.org/r/349245 )

Change subject: VisualEditor: Move Cite-specific wikitext handler tests here
......................................................................

VisualEditor: Move Cite-specific wikitext handler tests here

Change-Id: I26a61a8e42f68e679b5c74680f40d4237efb8f92
---
M includes/CiteHooks.php
A modules/ve-cite/tests/ve.ui.MWWikitextStringTransferHandler.test.js
2 files changed, 164 insertions(+), 0 deletions(-)


  git pull ssh://gerrit.wikimedia.org:29418/mediawiki/extensions/Cite 
refs/changes/45/349245/1

diff --git a/includes/CiteHooks.php b/includes/CiteHooks.php
index 7e3c5bf..1d2c7ea 100644
--- a/includes/CiteHooks.php
+++ b/includes/CiteHooks.php
@@ -56,6 +56,7 @@
                                        
'modules/ve-cite/tests/ve.dm.Converter.test.js',
                                        
'modules/ve-cite/tests/ve.dm.InternalList.test.js',
                                        
'modules/ve-cite/tests/ve.dm.Transaction.test.js',
+                                       
'modules/ve-cite/tests/ve.ui.MWWikitextStringTransferHandler.test.js',
                                ],
                                'dependencies' => [
                                        'ext.cite.visualEditor',
diff --git 
a/modules/ve-cite/tests/ve.ui.MWWikitextStringTransferHandler.test.js 
b/modules/ve-cite/tests/ve.ui.MWWikitextStringTransferHandler.test.js
new file mode 100644
index 0000000..350cfca
--- /dev/null
+++ b/modules/ve-cite/tests/ve.ui.MWWikitextStringTransferHandler.test.js
@@ -0,0 +1,163 @@
+/*!
+ * VisualEditor UserInterface Cite-specific MWWikitextStringTransferHandler 
tests.
+ *
+ * @copyright 2011-2017 Cite VisualEditor Team and others; see AUTHORS.txt
+ * @license The MIT License (MIT); see LICENSE.txt
+ */
+var MWWIKITEXT_MOCK_API = true;
+
+QUnit.module( 've.ui.MWWikitextStringTransferHandler (Cite)', 
QUnit.newMwEnvironment( {
+       setup: function () {
+               // Mock XHR for mw.Api()
+               this.server = MWWIKITEXT_MOCK_API ? 
this.sandbox.useFakeServer() : null;
+               ve.test.utils.mwEnvironment.setup.call( this );
+       },
+       teardown: ve.test.utils.mwEnvironment.teardown
+} ) );
+
+/* Tests */
+
+function runWikitextStringHandlerTest( assert, server, string, mimeType, 
expectedResponse, expectedData, annotations, assertDom, msg ) {
+       var handler, i, j, name,
+               done = assert.async(),
+               item = ve.ui.DataTransferItem.static.newFromString( string, 
mimeType ),
+               doc = ve.dm.Document.static.newBlankDocument(),
+               mockSurface = {
+                       getModel: function () {
+                               return {
+                                       getDocument: function () {
+                                               return doc;
+                                       }
+                               };
+                       },
+                       createProgress: function () {
+                               return $.Deferred().promise();
+                       }
+               };
+
+       // Preprocess the expectedData array
+       for ( i = 0; i < expectedData.length; i++ ) {
+               if ( Array.isArray( expectedData[ i ] ) ) {
+                       for ( j = 0; j < expectedData[ i ][ 1 ].length; j++ ) {
+                               if ( typeof expectedData[ i ][ 1 ][ j ] === 
'number' ) {
+                                       expectedData[ i ][ 1 ][ j ] = 
annotations[ expectedData[ i ][ 1 ][ j ] ];
+                               }
+                       }
+               }
+       }
+
+       // Check we match the wikitext string handler
+       name = ve.ui.dataTransferHandlerFactory.getHandlerNameForItem( item );
+       assert.strictEqual( name, 'wikitextString', msg + ': triggers match 
function' );
+
+       // Invoke the handler
+       handler = ve.ui.dataTransferHandlerFactory.create( 'wikitextString', 
mockSurface, item );
+
+       handler.getInsertableData().done( function ( docOrData ) {
+               var actualData, store;
+               if ( docOrData instanceof ve.dm.Document ) {
+                       actualData = docOrData.getData();
+                       store = docOrData.getStore();
+               } else {
+                       actualData = docOrData;
+                       store = new ve.dm.IndexValueStore();
+               }
+               ve.dm.example.postprocessAnnotations( actualData, store );
+               if ( assertDom ) {
+                       assert.equalLinearDataWithDom( store, actualData, 
expectedData, msg + ': data match (with DOM)' );
+               } else {
+                       assert.equalLinearData( actualData, expectedData, msg + 
': data match' );
+               }
+               done();
+       } );
+
+       if ( server && expectedResponse ) {
+               server.respond( [ 200, { 'Content-Type': 'application/json' }, 
JSON.stringify( {
+                       visualeditor: {
+                               result: 'success',
+                               content: '<body lang="en" class="mw-content-ltr 
sitedir-ltr ltr mw-body mw-body-content mediawiki" dir="ltr">' +
+                                       expectedResponse +
+                                       '</body>'
+                       }
+               } ) ] );
+       }
+}
+
+QUnit.test( 'convert', function ( assert ) {
+       var i,
+               cases = [
+                       {
+                               msg: 'Simple reference',
+                               pasteString: '<ref>Foo</ref>',
+                               pasteType: 'text/plain',
+                               parsoidResponse: '<p><span about="#mwt2" 
class="mw-ref" id="cite_ref-1" rel="dc:references" typeof="mw:Extension/ref" 
data-mw=\'{"name":"ref","body":{"id":"mw-reference-text-cite_note-1"},"attrs":{}}\'>[1]</span></p>'
 +
+                                       '<ol class="mw-references" 
typeof="mw:Extension/references" about="#mwt3" 
data-mw=\'{"name":"references","attrs":{},"autoGenerated":true}\'>' +
+                                               '<li about="#cite_note-1" 
id="cite_note-1">↑ <span id="mw-reference-text-cite_note-1" 
class="mw-reference-text">Foo</span></li>' +
+                                       '</ol>',
+                               annotations: [],
+                               expectedData: [
+                                       { type: 'paragraph' },
+                                       {
+                                               type: 'mwReference',
+                                               attributes: {
+                                                       mw: {
+                                                               attrs: {},
+                                                               body: {
+                                                                       id: 
'mw-reference-text-cite_note-1'
+                                                               },
+                                                               name: 'ref'
+                                                       },
+                                                       contentsUsed: true,
+                                                       listGroup: 
'mwReference/',
+                                                       listIndex: 0,
+                                                       listKey: 'auto/0',
+                                                       originalMw: 
'{"name":"ref","body":{"id":"mw-reference-text-cite_note-1"},"attrs":{}}',
+                                                       refGroup: '',
+                                                       refListItemId: 
'mw-reference-text-cite_note-1'
+                                               }
+                                       },
+                                       { type: '/mwReference' },
+                                       { type: '/paragraph' },
+                                       { type: 'internalList' },
+                                       { type: 'internalItem' },
+                                       { type: 'paragraph', internal: { 
generated: 'wrapper' } },
+                                       'F', 'o', 'o',
+                                       { type: '/paragraph' },
+                                       { type: '/internalItem' },
+                                       { type: '/internalList' }
+                               ]
+                       },
+                       {
+                               msg: 'Reference template with autoGenerated 
content',
+                               pasteString: '{{reference}}',
+                               pasteType: 'text/plain',
+                               parsoidResponse: '<p><span 
typeof="mw:Transclusion">[1]</span></p>' +
+                                       '<ol class="mw-references" 
typeof="mw:Extension/references" about="#mwt3" 
data-mw=\'{"name":"references","attrs":{},"autoGenerated":true}\'>' +
+                                               '<li>Reference list</li>' +
+                                       '</ol>',
+                               annotations: [],
+                               expectedData: [
+                                       {
+                                               type: 'mwTransclusionInline',
+                                               attributes: {
+                                                       mw: {},
+                                                       originalMw: null
+                                               }
+                                       },
+                                       {
+                                               type: '/mwTransclusionInline'
+                                       },
+                                       { type: 'internalList' },
+                                       { type: '/internalList' }
+                               ]
+                       }
+               ];
+
+       QUnit.expect( cases.length * 2 );
+       for ( i = 0; i < cases.length; i++ ) {
+               runWikitextStringHandlerTest(
+                       assert, this.server, cases[ i ].pasteString, cases[ i 
].pasteType, cases[ i ].parsoidResponse,
+                       cases[ i ].expectedData, cases[ i ].annotations, cases[ 
i ].assertDom, cases[ i ].msg
+               );
+       }
+} );

-- 
To view, visit https://gerrit.wikimedia.org/r/349245
To unsubscribe, visit https://gerrit.wikimedia.org/r/settings

Gerrit-MessageType: newchange
Gerrit-Change-Id: I26a61a8e42f68e679b5c74680f40d4237efb8f92
Gerrit-PatchSet: 1
Gerrit-Project: mediawiki/extensions/Cite
Gerrit-Branch: master
Gerrit-Owner: Jforrester <[email protected]>

_______________________________________________
MediaWiki-commits mailing list
[email protected]
https://lists.wikimedia.org/mailman/listinfo/mediawiki-commits

Reply via email to