Benutzer:Schnark/js/Template.js/test.js
aus Wikipedia, der freien Enzyklopädie
< Benutzer:Schnark | js | Template.js
Hinweis: Leere nach dem Veröffentlichen den Browser-Cache, um die Änderungen sehen zu können.
- Firefox/Safari: Umschalttaste drücken und gleichzeitig Aktualisieren anklicken oder entweder Strg+F5 oder Strg+R (⌘+R auf dem Mac) drücken
- Google Chrome: Umschalttaste+Strg+R (⌘+Umschalttaste+R auf dem Mac) drücken
- Internet Explorer/Edge: Strg+F5 drücken oder Strg drücken und gleichzeitig Aktualisieren anklicken
- Opera: Strg+F5
//<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);
var text = '{{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) {
var text = 'Vorne\n' +
'{{Infobox <!--Hilfe?-->\n' +
'| Param1 = Wert1\n' +
'| Parameter2 = Wert2\n' +
'| Param3 = Wert3\n' +
'}}\n' +
'Hinten',
template = new Template('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) {
var text = '{{TeMpLaTe:infobox_x|\n' +
' a =1|b= {{2}}|c\n' +
'=3 }}',
template = new Template('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) {
var text1 = '{{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 = new Template('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) {
var text = '{{Infobox|a=<!--|--><nowiki>|</nowiki>|b={{2|3}} [[2|3]]}}', //<nowiki>
template = new Template('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) {
var text = '{{V|a=1}}{{V|a=2}}', template;
assert.expect(5);
template = new Template('V', text);
assert.strictEqual(template.getVal('a'), '1', 'Wert von Parameter a erkannt');
assert.strictEqual(template.toString(), text, 'Roundtrip erfolgreich');
template = new Template('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 = new Template('V', text, 2);
}, 'Parsen fehlgeschlagen (mit 2)');
});
QUnit.test('Mehrfache Parameter', function (assert) {
var text = '{{V|a=1|a=2}}', template;
assert.expect(3);
assert.throws(function () {
template = new Template('V', text);
}, 'Parsen fehlgeschlagen (ohne Erlaubnis mehrfacher Parameter)');
template = new Template('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) {
var text = '{{V|a|b|3=c|d=4}}', template;
assert.expect(7);
assert.throws(function () {
template = new Template('V', text);
}, 'Parsen fehlgeschlagen (unbenannte Parameter verboten)');
template = new Template('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) {
var text1 = 'Einleitung\n' +
'{{Infobox\n' +
'| a = a\n' +
'| bc = bc\n' +
'<!-- Zwischenüberschrift -->\n',
text2 =
'| d =d\n' +
'|e=e\n' +
'}}',
text = text1 + text2,
template = new Template('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) {
var text = '{{Infobox \n' +
'| a = a \n' +
'| b = b\n' +
'| c =\n' +
'| d = \n' +
'}}',
template = new Template('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) {
var text = '{{V | a = a | b = b }}',
template = new Template('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) {
var text = '{{V|b=b|e=e}}', template = new Template('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) {
var anfang = '{{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 = new Template('Infobox', text),
template2 = new Template('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) {
var text1 = '{{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 = new Template('V', text1),
template2 = new Template('V', text2),
template3 = new Template('V', text3),
template4 = new Template('V', text4),
template5 = new Template('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) {
var text1 = '{{V|Rest=}}',
text2 = '{{V|Herr=A|Rest=}}',
text3 = '{{V|Rest=|Herrin=B}}',
text4 = '{{V|Herrin=B|Rest=|Herr=A}}',
template1 = new Template('V', text1),
template2 = new Template('V', text2),
template3 = new Template('V', text3),
template4 = new Template('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) {
var text1 = '{{V|Rest=}}',
text2 = '{{V|Rest=|Daten=viele}}',
text3 = '{{V|Stand=gestern|Rest=}}',
text4 = '{{V|Daten=viele|Stand=gestern|Rest=}}',
template1 = new Template('V', text1),
template2 = new Template('V', text2),
template3 = new Template('V', text3),
template4 = new Template('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>