Benutzer:Schnark/js/Template.js/test.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>
Benutzer:Schnark/js/Template.js/test.js

Navigationsmenü

Suche
