Benutzer:Schnark/js/Template.js/test.js

 //<nowiki>
 /*global mediaWiki, QUnit*/
 (function($,mw,Template,getLastError){
 "use strict";
 QUnit.module('Template');

 QUnit.test('Umgebung',function(assert){
 assert.expect(2);
 assert.ok(Template,'Template ist definiert');
 assert.ok(getLastError,'getLastError ist definiert');
 });
 QUnit.test('Funktioniert auch ohne new',function(assert){
 /*jshint newcap: false*/
 assert.expect(2);
 vartext='{{V|a=1}}{{V|a=2}}',template;
 template=Template('V',text);
 assert.ok(template!==null,'Parsen erfolgreich (ohne Nummer)');
 template=Template('V',text,2);
 assert.strictEqual(template,null,'Parsen fehlgeschlagen (mit 2)');
 });
 QUnit.test('Standard',function(assert){
 vartext='Vorne\n'+
 '{{Infobox <!--Hilfe?-->\n'+
 '| Param1 = Wert1\n'+
 '| Parameter2 = Wert2\n'+
 '| Param3 = Wert3\n'+
 '}}\n'+
 'Hinten',
 template=newTemplate('Infobox',text);

 assert.expect(14);

 assert.strictEqual(template.getVal('Param1'),'Wert1','Wert von Param1 erkannt');
 assert.strictEqual(template.getVal('Param4'),undefined,'Unbekannter Parameter erkannt');
 assert.strictEqual(template.toString(),text,'Roundtrip erfolgreich');

 assert.ok(template.insert('Param1.5','Wert1.5','Param1'),'Param1.5 erfolgreich eingfügt');
 assert.ok(template.toString().indexOf('| Param1 = Wert1\n| Param1.5 = Wert1.5\n|')!==-1,
 'Einrückung und Einfügung korrekt');

 assert.ok(template.remove('Param1'),'Param1 erfolgreich gelöscht');
 assert.ok(template.toString().indexOf('<!--Hilfe?-->\n| Param1.5')!==-1,'Löschung korrekt');

 assert.ok(template.rename('Param1.5','Param1'),'Umbenennung erfolgreich');
 assert.ok(template.change('Param1','Wert1'),'Änderung erfolgreich');
 assert.strictEqual(template.toString(),text,'Ursprungszustand erfolgreich wieder hergestellt');

 assert.ok(template.insert('Param4','Wert4'),'Param4 erfolgreich angehängt');
 assert.ok(template.toString().indexOf('| Param3 = Wert3\n| Param4 = Wert4\n}}')!==-1,'Anfügung korrekt');

 assert.ok(template.move('Param4','Param1'),'Verschiebung erfolgreich');
 assert.ok(template.toString().indexOf('| Param1 = Wert1\n| Param4 = Wert4\n|')!==-1,'Verschiebung korrekt');
 });
 QUnit.test('Finden',function(assert){
 vartext='{{TeMpLaTe:infobox_x|\n'+
 ' a =1|b= {{2}}|c\n'+
 '=3 }}',
 template=newTemplate('Infobox x',text);

 assert.expect(6);

 assert.strictEqual(template.getVal('a'),'1','Wert von Parameter a erkannt');
 assert.strictEqual(template.getVal('b'),'{{2}}','Wert von Parameter b erkannt');
 assert.strictEqual(template.getVal('c'),'3 ','Wert von Parameter c erkannt');
 assert.strictEqual(template.toString(),'{{Infobox x|\n a =1|b= {{2}}|c\n=3 }}',
 'Roundtrip erfolgreich (nur Vorlagenname angepasst)');
 assert.ok(template.insert('d','d'),'Parameter d erfolgreich angehängt');
 assert.strictEqual(template.toString(),'{{Infobox x|\n a =1|b= {{2}}|c\n=3 |d =d}}',
 'Formatierung so gut wie möglich');
 });
 QUnit.test('Kommentare',function(assert){
 vartext1='{{asdf}}\n'+
 '{{Infobox<!--Hilfe?-->\n'+
 '<!-- 1 -->\n'+
 '|a=1 <!--zu a}}-->\n',
 text2='<!--|b= -->\n',
 text3='<!-- 3| -->\n'+
 '|c=3}}<!--Ende-->',
 text=text1+text2+text3,
 template=newTemplate('Infobox',text);

 assert.expect(3);

 assert.strictEqual(template.getVal('a'),'1 <!--zu a}}-->','Wert von Parameter a erkannt');
 assert.strictEqual(template.getVal('b'),undefined,'Parameter b nicht gefunden');
 assert.strictEqual(template.toString(),text1+text3,'Roundtrip erfolgreich (nur auskommentierten Parameter entfernt)');
 });
 QUnit.test('Pipe',function(assert){
 vartext='{{Infobox|a=<!--|--><nowiki>|</nowiki>|b={{2|3}} [[2|3]]}}',//<nowiki>
 template=newTemplate('Infobox',text);

 assert.expect(3);

 assert.strictEqual(template.getVal('a'),'<!--|--><nowiki>|</nowiki>','Wert von Parameter a erkannt');//<nowiki>
 assert.strictEqual(template.getVal('b'),'{{2|3}} [[2|3]]','Wert von Parameter b erkannt');
 assert.strictEqual(template.toString(),text,'Roundtrip erfolgreich');
 });
 QUnit.test('Mehrfaches Vorkommen der Vorlage',function(assert){
 vartext='{{V|a=1}}{{V|a=2}}',template;

 assert.expect(5);

 template=newTemplate('V',text);
 assert.strictEqual(template.getVal('a'),'1','Wert von Parameter a erkannt');
 assert.strictEqual(template.toString(),text,'Roundtrip erfolgreich');

 template=newTemplate('V',text,1);
 assert.strictEqual(template.getVal('a'),'2','Wert von Parameter a erkannt');
 assert.strictEqual(template.toString(),text,'Roundtrip erfolgreich');

 assert.throws(function(){
 template=newTemplate('V',text,2);
 },'Parsen fehlgeschlagen (mit 2)');
 });
 QUnit.test('Mehrfache Parameter',function(assert){
 vartext='{{V|a=1|a=2}}',template;

 assert.expect(3);

 assert.throws(function(){
 template=newTemplate('V',text);
 },'Parsen fehlgeschlagen (ohne Erlaubnis mehrfacher Parameter)');

 template=newTemplate('V',text,0,true);
 assert.strictEqual(template.getVal('a'),'2','Wert von Parameter a erkannt');
 assert.strictEqual(template.toString(),'{{V|a=2}}','Roundtrip erfolgreich (nur überflüssigen Parameter entfernt)');
 });
 QUnit.test('Unbenannte Parameter',function(assert){
 vartext='{{V|a|b|3=c|d=4}}',template;

 assert.expect(7);

 assert.throws(function(){
 template=newTemplate('V',text);
 },'Parsen fehlgeschlagen (unbenannte Parameter verboten)');

 template=newTemplate('V',text,0,false,true);
 assert.strictEqual(template.getVal('2'),'b','Wert von Parameter 2 erkannt');
 assert.strictEqual(template.toString(),'{{V|a|b|c|d=4}}','Roundtrip erfolgreich (nur überflüssiges 3= entfernt)');

 assert.ok(template.change('2','='),'Parameter 2 erfolgreich geändert');
 assert.strictEqual(template.toString(),'{{V|a|2==|3=c|d=4}}','Korrekte Ausgabe bei Gleichheitszeichen');

 assert.ok(template.rename('2','b'),'Parameter 2 erfolgreich umbenannt');
 assert.strictEqual(template.toString(),'{{V|a|b==|3=c|d=4}}','Korrekte Ausgabe bei Umbenennung');
 });
 QUnit.test('Einrückung',function(assert){
 vartext1='Einleitung\n'+
 '{{Infobox\n'+
 '| a = a\n'+
 '| bc = bc\n'+
 '<!-- Zwischenüberschrift -->\n',
 text2=
 '| d =d\n'+
 '|e=e\n'+
 '}}',
 text=text1+text2,
 template=newTemplate('Infobox',text);

 assert.expect(5);

 assert.strictEqual(template.toString(),text,'Roundtrip erfolgreich');
 assert.deepEqual(template.getIndention(),[1,0,1,-9,1,0],'Einrückung richtig erkannt');
 template.normalize();
 assert.strictEqual(template.toString(),text1+'| d = d\n| e = e\n}}','Normalisierung erfolgreich');
 template.setIndention(undefined,undefined,undefined,1);
 template.normalize();
 assert.strictEqual(template.toString(),'Einleitung\n'+
 '{{Infobox\n'+
 '| a = a\n'+
 '| bc = bc\n'+
 '<!-- Zwischenüberschrift -->\n'+
 '| d = d\n'+
 '| e = e\n'+
 '}}','Änderung der Einrückung erfolgreich');
 template.remove('~~~~comment0');
 template.setIndention(0,0,0,0,0);
 template.normalize();
 assert.strictEqual(template.toString(),'Einleitung\n{{Infobox|a=a|bc=bc|d=d|e=e}}',
 'Änderung der Einrückung erfolgreich');
 });
 QUnit.test('Leerzeichen am Zeilenende',function(assert){
 vartext='{{Infobox \n'+
 '| a = a \n'+
 '| b = b\n'+
 '| c =\n'+
 '| d = \n'+
 '}}',
 template=newTemplate('Infobox',text);

 assert.expect(5);

 assert.strictEqual(template.toString(),text,'Roundtrip erfolgreich');
 template.normalize();
 assert.strictEqual(template.toString(),'{{Infobox \n| a = a \n| b = b\n| c =\n| d =\n}}',
 'Leerzeichen bei leeren Parametern entfernt');
 template.setIndention(undefined,undefined,undefined,undefined,undefined,1);
 template.normalize();
 assert.strictEqual(template.toString(),'{{Infobox \n| a = a \n| b = b\n| c = \n| d = \n}}',
 'Leerzeichen bei leeren Parametern angefügt');
 template.trim();
 assert.strictEqual(template.toString(),'{{Infobox\n| a = a\n| b = b\n| c = \n| d = \n}}',
 'Schließende Leerzeichen entfernt');
 template.setIndention(undefined,undefined,undefined,undefined,undefined,0);
 template.normalize();
 template.change('b','');
 template.change('c','c');
 assert.strictEqual(template.toString(),'{{Infobox\n| a = a\n| b =\n| c = c\n| d =\n}}',
 'Leerzeichen genau bei leeren Parametern auch nach Änderung');
 });
 QUnit.test('Leerzeichen bei einzeiligen Vorlagen',function(assert){
 vartext='{{V | a = a | b = b }}',
 template=newTemplate('V',text);

 assert.expect(3);

 assert.strictEqual(template.toString(),text,'Roundtrip erfolgreich');
 assert.ok(template.change('a','a'),'Wert erfolgreich auf sich selbst gesetzt');
 assert.strictEqual(template.toString(),text,'Leerzeichen bleiben erhalten');
 });
 QUnit.test('Einfügen',function(assert){
 vartext='{{V|b=b|e=e}}',template=newTemplate('V',text);

 assert.expect(11);

 assert.ok(template.insert('c','c','b'),'c nach b eingfügt');
 assert.strictEqual(template.toString(),'{{V|b=b|c=c|e=e}}','Korrekte Vorlage nach Einfügen von c');

 assert.ok(template.insert('g','g','f'),'g nach f eingfügt');
 assert.strictEqual(template.toString(),'{{V|b=b|c=c|e=e|g=g}}','Korrekte Vorlage nach Einfügen von g');

 assert.ok(template.insert('h','h'),'h angehängt');
 assert.strictEqual(template.toString(),'{{V|b=b|c=c|e=e|g=g|h=h}}','Korrekte Vorlage nach Einfügen von h');

 assert.ok(template.insert('f','f','g',true),'f vor g eingfügt');
 assert.strictEqual(template.toString(),'{{V|b=b|c=c|e=e|f=f|g=g|h=h}}','Korrekte Vorlage nach Einfügen von f');

 assert.ok(template.insert('a','a','d',true),'a vor d eingfügt');
 assert.strictEqual(template.toString(),'{{V|a=a|b=b|c=c|e=e|f=f|g=g|h=h}}','Korrekte Vorlage nach Einfügen von a');

 assert.ok(!template.insert('a','a'),'a nicht nochmals eingfügt');
 });
 QUnit.test('Sortieren',function(assert){
 varanfang='{{Infobox <!--Hilfe?-->\n',
 bc='<!-- zu b + c-->\n'+
 '|b=b\n'+
 '|c=c\n',
 a='<!-- zu a -->\n'+
 '|a=a\n',
 d='|d=d\n'+
 '<!--Ende-->\n'+
 '}}',
 text=anfang+bc+a+d,
 template1=newTemplate('Infobox',text),
 template2=newTemplate('Infobox',text),
 folge=['a','b','c'];

 assert.expect(5);

 assert.ok(!template1.sort(folge),'Sortieren gescheitert, unbekannter Parameter');

 assert.ok(template1.sort(folge,true),'Sortieren erfolgreich');
 assert.strictEqual(template1.toString(),anfang+a+bc+d,'Sortierung korrekt');

 folge.push('d');
 assert.ok(template2.sort(folge),'Sortieren erfolgreich');
 assert.strictEqual(template2.toString(),anfang+a+bc+d,'Sortierung korrekt');
 });
 QUnit.test('Validieren - Parameter und Werte',function(assert){
 vartext1='{{V|Pflicht=A|Optional=B|Zahl=3}}',
 text2='{{V|Pflicht=A}}',
 text3='{{V|Optional=B}}',
 text4='{{V|Pflicht=A|Zahl=C}}',
 text5='{{V|Pflicht=A|Optional=B|Zahl=3|Unbekannt=D}}',
 template1=newTemplate('V',text1),
 template2=newTemplate('V',text2),
 template3=newTemplate('V',text3),
 template4=newTemplate('V',text4),
 template5=newTemplate('V',text5),

 val={'Zahl':{optional:true,re:/^\d+\s*$/},
 'Pflicht':{},
 'Optional':{optional:true}
 };

 assert.expect(5);

 assert.ok(template1.validate(val),'vieles da -> OK');
 assert.ok(template2.validate(val),'Pflicht da -> OK');
 assert.ok(!template3.validate(val),'Pflicht fehlt -> Fehler');
 assert.ok(!template4.validate(val),'keine Zahl -> Fehler');
 assert.ok(!template5.validate(val),'unbekannter Parameter -> Fehler');
 });
 QUnit.test('Validieren - oneGroup',function(assert){
 vartext1='{{V|Rest=}}',
 text2='{{V|Herr=A|Rest=}}',
 text3='{{V|Rest=|Herrin=B}}',
 text4='{{V|Herrin=B|Rest=|Herr=A}}',
 template1=newTemplate('V',text1),
 template2=newTemplate('V',text2),
 template3=newTemplate('V',text3),
 template4=newTemplate('V',text4),

 val1={'Rest':{},'Herr':{oneGroup:'HerrIn'},'Herrin':{oneGroup:'HerrIn'}},
 val2={'Rest':{},'Herr':{oneGroup:'HerrIn',optional:true},'Herrin':{oneGroup:'HerrIn',optional:true}};

 assert.expect(8);

 assert.ok(!template1.validate(val1),'nichts vorhanden -> Fehler');
 assert.ok(template1.validate(val2),'nichts vorhanden, aber optional -> OK');

 assert.ok(template2.validate(val1),'eins vorhanden -> OK');
 assert.ok(template2.validate(val2),'eins vorhanden -> OK');

 assert.ok(template3.validate(val1),'eins vorhanden -> OK');
 assert.ok(template3.validate(val2),'eins vorhanden -> OK');

 assert.ok(!template4.validate(val1),'beide vorhanden -> Fehler');
 assert.ok(!template4.validate(val2),'beide vorhanden -> Fehler');
 });
 QUnit.test('Validieren - allGroup',function(assert){
 vartext1='{{V|Rest=}}',
 text2='{{V|Rest=|Daten=viele}}',
 text3='{{V|Stand=gestern|Rest=}}',
 text4='{{V|Daten=viele|Stand=gestern|Rest=}}',
 template1=newTemplate('V',text1),
 template2=newTemplate('V',text2),
 template3=newTemplate('V',text3),
 template4=newTemplate('V',text4),

 val={
 'Rest':{},
 'Daten':{allGroup:'Daten + Stand',optional:true},
 'Stand':{allGroup:'Daten + Stand',optional:true}
 };

 assert.expect(4);

 assert.ok(template1.validate(val),'nichts vorhanden -> OK');
 assert.ok(!template2.validate(val),'eins vorhanden -> Fehler');
 assert.ok(!template3.validate(val),'eins vorhanden -> Fehler');
 assert.ok(template4.validate(val),'beide vorhanden -> OK');
 });
 })(jQuery,mediaWiki,mediaWiki.libs.Template,mediaWiki.libs.templateGetLastError);
 //</nowiki>