Benutzer:Schnark/js/templateEditor.js/test.js

//<nowiki>
/*global mediaWiki, QUnit*/
/*jshint camelcase: false*///nur name1_0 etc.
//jscs:disable requireCamelCaseOrUpperCaseIdentifiers
(function ($, mw, templateEditor) {
"use strict";

mw.loader.using(['mediawiki.util', 'mediawiki.language', 'mediawiki.jqueryMsg']).then(function () {
//virtual indent

QUnit.module('TemplateEditor');

QUnit.test('Kompletttest', function (assert) {
//virtual indent
assert.expect(1 + 4 + 10 + 22 + 2 + 10 + 16 + 3 + 26 + 6 + 5 + 9 + 10);
var erster1 = true, erster2 = true,
	fA, fB, fC, fAB,
	hA = {
		onStart: function () {
			assert.ok(false, 'A.onStart wurde aufgerufen');
		},
		onReady: function () {
			var a1, $row;
			erster1 = false;

			a1 = fA.addInput('1', {
					text: 'A1',
					autofill: true,
					autocorr: function (a) {
						return a.toLowerCase();
					},
					val: 'AA'}
				);
			a1.html('Hinweis zu <span id="element-des-hinweises">A1</span>');
			assert.ok(a1, 'Eingabefeld A1 mit Automatik und zusätzlichem HTML erzeugt');
			assert.ok(!fA.addInput('1', {text: 'A1_'}), 'Doppelte Erzeugung verhindert');
			assert.ok(fA.addInput('2', {text: 'A2', type: 'bool', val: true}),
				'Kontrollkästchen A2 erzeugt');

			$row = $('<tr><td>Zusatzzeile</td><td>für</td><td><span id="element-der-zusatzzeile">A</span></td></tr>');
			assert.strictEqual(fA.addRow($row), $row, 'Zusatzzeile eingefügt');
			fA.addFootitem('<span id="element-der-fusszeile-1">1</span>');
			fA.addFootitem('<span id="element-der-fusszeile-2">2</span>');
		},
		onFinish: function () {
			erster2 = false;
			fA.setText('Neuer Text');
			fA.addComment('A war hier');
		}
	},
	hB = {
		onStart: function (o) {
			assert.strictEqual(o.id, 'QUnit-A', 'B.onStart aufgerufen, ID korrekt');
			assert.strictEqual(o.data.foo, 'bar', 'Daten korrekt übergeben');
			return -1;
		},
		onReady: function () {
			assert.ok(erster1, 'B.onReady wurde vor A.onReady aufgerufen');
			assert.ok(fB.addInput('1', {text: 'B1'}), 'Standard-Eingabefeld B1 erzeugt');
		},
		onFinish: function () {
			assert.ok(erster2, 'B.onFinish wurde vor A.onFinish aufgerufen');
			fB.addComment('B war hier');
		}
	},
	hC = {
		onStart: function (o) {
			assert.strictEqual(o.id, 'QUnit-A', 'C.onStart aufgerufen, ID korrekt');
			return 0;
		},
		onReady: function () {
			assert.ok(false, 'C.onReady wurde aufgerufen');
		},
		onFinish: function () {
			assert.ok(false, 'C.onFinish wurde aufgerufen');
		}
	},

	$table = $('<div>'), $form,
	$b1_0, $b1_1, $b1_2,
	$a1_0, $a1_1, $a1_2,
	$a2_0, $a2_1, $a2_2,
	$head, $foot, $rows,
	v1, v2, v3,
	$sugg, $el,
	$liste, $option1, $option2,
	inject;

//** Umgebung (1) **
templateEditor.qunit = true;
assert.ok(templateEditor, 'templateEditor ist definiert');

//** Registrieren (4) **
fA = templateEditor('QUnit-A', 'a', 2.0, hA);
fB = templateEditor('QUnit-B', 'b', '3.0', hB);
fC = templateEditor('QUnit-C', 'c', 'alpha', hC);
assert.ok(fA, 'QUnit-A erfolgreich registriert');
assert.ok(fB, 'QUnit-B erfolgreich registriert');
assert.ok(fC, 'QUnit-C erfolgreich registriert');
assert.ok(!templateEditor('QUnit-C', 'c', 'alpha', hC),
	'Doppelte Registrierung verhindert');

//** Starten/Aufbauen (1 + 2 B.onStart + 1 C.onStart + 4 A.onReady + 2 B.onReady) **
//NB: synchron, da alle benötigten Module explizit vorher geladen!
assert.ok(fA.start({$: $table, headline: 'Überschrift', foo: 'bar'}), 'Start erfolgreich');

//** Verifikation des Aufbaus (22) **
$head = $table.find('thead');
$foot = $table.find('tfoot');
$rows = $table.find('tbody tr');

//Kopf
assert.strictEqual($head.length, 1, 'Kopfzeile vorhanden');
assert.ok($head.text().indexOf('Überschrift') > -1, 'Kopfzeile enthält Überschrift');

//Körper
assert.strictEqual($rows.length, 4, 'Vier Zeilen im Körper vorhanden');

$b1_0 = $rows.eq(0).find('td').eq(0);
$b1_1 = $rows.eq(0).find('td').eq(1).find('input');
$b1_2 = $rows.eq(0).find('td').eq(2);
assert.ok($b1_0.text().indexOf('B1') > -1, 'Beschriftung B1 vorhanden');
assert.strictEqual($b1_1.attr('type'), 'text', 'B1 ist Texteingabefeld');
assert.strictEqual($b1_1.val(), '', 'B1 enthält Leerstring');
assert.strictEqual($b1_2.text(), '', 'B1 hat keine Zusatzinformationen');

$a1_0 = $rows.eq(1).find('td').eq(0);
$a1_1 = $rows.eq(1).find('td').eq(1).find('input');
$a1_2 = $rows.eq(1).find('td').eq(2);
assert.ok($a1_0.text().indexOf('A1') > -1, 'Beschriftung A1 vorhanden');
assert.strictEqual($a1_1.attr('type'), 'text', 'A1 ist Texteingabefeld');
assert.strictEqual($a1_1.val(), 'aa', 'A1 enthält "aa"');
assert.ok($a1_2.text().indexOf('automatisch korrigiert') > -1,
	'A1 hat "automatisch korrigiert" als Zusatzinformation');
assert.strictEqual($a1_2.find('#element-des-hinweises').length, 1,
	'A1 enthält gewünschte Zusatzinformation');

$a2_0 = $rows.eq(2).find('td').eq(0);
$a2_1 = $rows.eq(2).find('td').eq(1).find('input');
$a2_2 = $rows.eq(2).find('td').eq(2);
assert.strictEqual($a2_0.text(), '', 'Erste Spalte für A2 leer');
assert.ok($rows.eq(2).find('td').eq(1).text().indexOf('A2') > -1,
	'Beschriftung A2 vorhanden');
assert.strictEqual($a2_1.attr('type'), 'checkbox', 'A2 ist Kontrollkästchen');
assert.strictEqual($a2_1.prop('checked'), true, 'A2 ist angekreuzt');
assert.strictEqual($a2_2.text(), '', 'A2 hat keine Zusatzinformationen');

assert.strictEqual($rows.eq(3).find('#element-der-zusatzzeile').length, 1,
	'Zusatzzeile enthält gewünschten Inhalt');

//Fuß
assert.strictEqual($foot.length, 1, 'Fußzeile vorhanden');
assert.strictEqual($foot.find('#element-der-fusszeile-1').length, 1,
	'Eintrag in Fußzeile vorhanden');
assert.strictEqual($foot.find('#element-der-fusszeile-1').next('#element-der-fusszeile-2').length, 1,
	'Zweiter Eintrag hinter dem ersten vorhanden');
assert.ok($foot.text().indexOf(' • ') > -1, 'Trenner vorhanden');

//** Verhinderung weiterer Registrierungen/Starts (2) **
assert.ok(!templateEditor('QUnit-D', 'd', 1.0, hC),
	'Nachträgliche Registrierung verhindert');
assert.ok(!fC.start(), 'Nachträglicher Start verhindert');

//** Version (10) **
v1 = fA.getVersion();
v2 = fA.getVersion(false);
v3 = fA.getVersion(true);
assert.strictEqual(typeof v1, 'number', '.getVersion() liefert eine Zahl');
assert.ok(v1 >= 1.4, '... und zwar mindestens 1.4');
assert.strictEqual(typeof v2, 'string', '.getVersion(false) liefert einen String');
assert.ok(v2.indexOf(String(v1)) === 0, '... der mit der Grundversion beginnt');
assert.ok(v2.indexOf('a-2.0') > -1 && v2.indexOf('b-3.0') > -1 && v2.indexOf('c-alpha') > -1,
	'... und alle Plugins auflistet');
assert.strictEqual(typeof v3, 'string', '.getVersion(true) liefert einen String');
assert.ok(v3.indexOf(String(v1)) === 0, '... der mit der Grundversion beginnt');
assert.ok(v3.indexOf('a-2.0') > -1 && v3.indexOf('b-3.0') > -1 && v3.indexOf('c-alpha') === -1,
	'... und alle aktiven Plugins auflistet');
assert.strictEqual(fA.getVersion('QUnit-B'), '3.0',
	'.getVersion("id") liefert korrekte Version bei vorhandenen Plugins');
assert.strictEqual(fA.getVersion('QUnit-D'), null,
	'.getVersion("id") liefert null bei fehlenden Plugins');

//** Lesen und Schreiben (16) **

assert.strictEqual(fB.getVal('2'), null, 'Lesen eines fehlenden Elements liefert null');
assert.strictEqual(fB.setVal('2', 'x'), null,
	'Schreiben eines fehlenden Elements liefert null');

assert.strictEqual(fB.getVal('1'), '', 'Lesen von B1 liefert Leerstring');
$b1_1.val('b1');
assert.strictEqual(fB.getVal('1'), 'b1', 'Lesen von B1 liefert "b1"');
assert.strictEqual(fB.setVal('1', 'BB')[0], $b1_1[0],
	'Schreiben von B1 liefert korrektes Eingabefeld');
assert.strictEqual($b1_1.val(), 'BB', 'B1 enthält "BB"');

assert.strictEqual(fA.getVal('1'), 'aa', 'Lesen von A1 liefert "aa"');
$a1_1.val('A1');
assert.strictEqual(fA.getVal('1'), 'a1', 'Lesen von A1 liefert "a1"');
assert.strictEqual(fA.setVal('1', 'AA')[0], $a1_1[0],
	'Schreiben von A1 liefert korrektes Eingabefeld');
assert.strictEqual($a1_1.val(), 'aa', 'A1 enthält "aa"');

assert.strictEqual(fA.getVal('2'), true, 'Lesen von A2 liefert true');
$a2_1.prop('checked', false);
assert.strictEqual(fA.getVal('2'), false, 'Lesen von A2 liefert false');
assert.strictEqual(fA.setVal('2', true)[0], $a2_1[0],
	'Schreiben von A2 liefert korrektes Kontrollkästchen');
assert.strictEqual($a2_1.prop('checked'), true, 'A2 ist angekreuzt');

assert.deepEqual(fA.getVal(), {'1': 'aa', '2': true},
	'Lesen aller Werte von A erfolgreich');
assert.deepEqual(fB.getVal(), {'1': 'BB'}, 'Lesen aller Werte von B erfolgreich');

//** Plugin-übergreifende Zugriffe (3) **
assert.strictEqual(fA.getFunctions('QUnit-D'), false,
	'Anfrage nach Funktionen fehldender Plugins liefert false');
fAB = fA.getFunctions('QUnit-B');
assert.ok(fAB, 'Anfrage nach Funktionen von B erfolgreich');
assert.strictEqual(fAB.getVal('1'), 'BB', 'Wert von B1 durch A korrekt ausgelesen');

//** Vorschläge (26) **
fB.setVal('1', '');
fB.setSuggestions('1', 'Vorschlag');
$sugg = $b1_2.find('.templateEditor-suggestion');
assert.strictEqual($b1_1.val(), '',
	'Feld wurde nicht automatisch mit dem Vorschlag gefüllt');
assert.strictEqual($sugg.length, 1, 'Ein Vorschlag vorhanden');
$sugg.eq(0).trigger('click');
assert.strictEqual($b1_1.val(), 'Vorschlag', 'Vorschlag nach Klick übernommen');

fB.setSuggestions('1', ['']);
$sugg = $b1_2.find('.templateEditor-suggestion');
assert.strictEqual($b1_1.val(), 'Vorschlag',
	'Feld wurde nicht automatisch mit dem Vorschlag gefüllt');
assert.strictEqual($sugg.length, 1, 'Ein Vorschlag vorhanden');
$sugg.eq(0).trigger('click');
assert.strictEqual($b1_1.val(), '', 'Vorschlag nach Klick übernommen');

fB.setSuggestions('1', ['11', '22', '33']);
$sugg = $b1_2.find('.templateEditor-suggestion');
assert.strictEqual($b1_1.val(), '',
	'Feld wurde nicht automatisch mit dem Vorschlag gefüllt');
assert.strictEqual($sugg.length, 3, 'Alle Vorschläge vorhanden');
$sugg.eq(1).trigger('click');
assert.strictEqual($b1_1.val(), '22', 'Gewählter Vorschlag nach Klick übernommen');

fB.setSuggestions('1', null);
$sugg = $b1_2.find('.templateEditor-suggestion');
assert.strictEqual($b1_1.val(), '22', 'Feld wurde nicht automatisch geleert');
assert.strictEqual($sugg.length, 0, 'Kein Vorschlag vorhanden');

fA.setVal('1', '');
fA.setSuggestions('1', 'vorschlag');
$sugg = $a1_2.find('.templateEditor-suggestion');
assert.strictEqual($a1_1.val(), 'vorschlag',
	'Feld wurde automatisch mit dem Vorschlag gefüllt');
assert.strictEqual($sugg.length, 0, 'Kein Vorschlag angezeigt');
assert.ok($a1_2.text().indexOf('automatisch hinzugefügt') > -1,
	'Hinweis auf automatische Übernahme vorhanden');

fA.setSuggestions('1', ['11', '22', '33']);
$sugg = $a1_2.find('.templateEditor-suggestion');
assert.strictEqual($a1_1.val(), '', 'Feld wurde automatisch zurückgesetzt');
assert.strictEqual($sugg.length, 3, 'Alle Vorschläge vorhanden');
assert.strictEqual($a1_2.text().indexOf('automatisch hinzugefügt'), -1,
	'Kein Hinweis auf automatische Übernahme vorhanden');
$sugg.eq(1).trigger('click');
assert.strictEqual($b1_1.val(), '22', 'Gewählter Vorschlag nach Klick übernommen');

fA.setSuggestions('1', null);
$sugg = $a1_2.find('.templateEditor-suggestion');
assert.strictEqual($a1_1.val(), '22', 'Feld wurde nicht automatisch geleert');
assert.strictEqual($sugg.length, 0, 'Kein Vorschlag vorhanden');

fA.setVal('1', '');
fA.setSuggestions('1', 'vorschlag');
assert.strictEqual($a1_1.val(), 'vorschlag',
	'Feld wurde automatisch mit dem Vorschlag gefüllt');
$a1_1.val('Handeingabe').trigger('change');
fA.setSuggestions('1', ['11', '22', '33']);
assert.strictEqual($a1_1.val(), 'Handeingabe',
	'Feld wurde nach Handeingabe nicht automatisch zurückgesetzt');

fA.setVal('1', '');
fA.setSuggestions('1', 'vorschlag');
assert.strictEqual($a1_1.val(), 'vorschlag',
	'Feld wurde automatisch mit dem Vorschlag gefüllt');
$a1_1.val('').trigger('change');
assert.strictEqual($a1_1.val(), '', 'Leerung von Hand wird akzeptiert');
$sugg = $a1_2.find('.templateEditor-suggestion');
assert.strictEqual($sugg.length, 1, 'Ein Vorschlag vorhanden');
$sugg.eq(0).trigger('click');
assert.strictEqual($a1_1.val(), 'vorschlag', 'Vorschlag nach Klick übernommen');

//** Listen (6) **
fB.setList('1', [['x', 'xx'], ['y', 'yy'], ['z', 'zz']], 'Liste');
$liste = $b1_2.find('select');
$option1 = $liste.find('option').eq(0);
$option2 = $liste.find('option').eq(2);
assert.strictEqual($liste.length, 1, 'Auswahlliste erfolgreich hinzugefügt');
assert.strictEqual($liste.find('option').length, 4, 'Liste hat 4 Einträge');
assert.strictEqual($option1.text(), 'Liste', 'Liste hat korrekte Überschrift');
assert.strictEqual($option2.text(), 'y', 'Dritter Eintrag korrekt beschriftet');
$option2.prop('selected', true);
$liste.trigger('change');
assert.strictEqual(fB.getVal('1'), 'yy',
	'Feld beim Auswählen des Eintrags korrekt befüllt');
$option1.prop('selected', true);
$liste.trigger('change');
assert.strictEqual(fB.getVal('1'), '',
	'Feld beim Auswählen des ersten Eintrags auf Ausgangswert zurückgesetzt');

//** XSS (5) **
inject = '" onclick="QUnit.ok(false,\'XSS\');" title="<script>QUnit.ok(false,\'XSS\');</script>';

fB.setSuggestions('1', inject);
$el = $b1_2.find('.templateEditor-suggestion');
assert.ok($el.text().indexOf(inject) > -1, 'Angezeigter Text enthält gesamten String');
$el.eq(0).trigger('click');
assert.strictEqual($b1_1.val(), inject, 'Gesamter String nach Klick übernommen');

$b1_1.val('');
fB.setList('1', [[inject, inject]]);
$el = $b1_2.find('select option').eq(1);
assert.strictEqual($el.text(), inject, 'Gesamter String als Listeneintrag');
assert.strictEqual($el.attr('value'), inject,
	'Gesamter String als Wert des Listeneintrags');
$el.prop('selected', true);
$b1_2.find('select').trigger('change');
assert.strictEqual($b1_1.val(), inject, 'Gesamter String nach Auswahl übernommen');

//** Hilfsfunktionen (9) **
assert.strictEqual(fA.get$('1')[0], $a1_1[0], '.get$ liefert korrektes Eingabefeld');
assert.strictEqual(fA.get$('1', 'warning')[0], $a1_2.find('.templateEditor-comment')[0],
	'.get$("warning") liefert korrektes Ergebnis');
assert.strictEqual(fA.get$('1', 'list')[0], $a1_2.find('.templateEditor-list')[0],
	'.get$("list") liefert korrektes Ergebnis');
assert.strictEqual(fA.get$('1', 'additional')[0], $a1_2.find('.templateEditor-additional')[0],
	'.get$("additional") liefert korrektes Ergebnis');
fA.setWarning('1', 'foo');
assert.strictEqual(fA.get$('1', 'warning').text(), 'foo',
	'.setWarning hat korrekte Warnung angezeigt');
assert.strictEqual(fA.getWarning('1'), 'foo', '.getWarning liefert korrekte Warnung');
assert.strictEqual(fA.getTitle(), mw.config.get('wgTitle'),
	'.getTitle liefert korrekten Titel');
assert.strictEqual(fA.getText(), 'text', '.getText liefert korrekten Text');
assert.strictEqual(typeof fA.setNotMinor, 'function', '.setNotMinor vorhanden');

//** Beenden (9 + 1 B.onFinish) **
$table.find('.templateEditorButton').eq(0).trigger('click');
$form = $('body').find('form');
$form = $form.eq($form.length - 1);
assert.strictEqual($form.attr('method').toLowerCase(), 'post',
	'Formular wird per POST verarbeitet');
assert.ok(/\?title=.*&action=(?:edit|submit)(?:&|$)/.test($form.attr('action')),
	'Formular wird mit Parametern title und action=edit in der URL versendet');
assert.strictEqual($form.find('textarea[name="wpTextbox1"]').val(), 'Neuer Text',
	'wpTextbox1 enthält korrekten Text');
assert.strictEqual($form.find('input[name="wpSummary"]').val(), 'B war hier, A war hier',
	'wpSummary enthält korrekte Zusammenfassung');
assert.strictEqual($form.find('input[name="wpMinoredit"]').prop('checked'), true,
	'wpMinoredit ist angekreuzt');
assert.strictEqual($form.find('input[name="wpWatchthis"]').prop('checked'), false,
	'wpWatchthis ist nicht angekreuzt');
assert.strictEqual($form.find('input[name="wpEdittime"]').val(), 'edittime',
	'wpEdittime ist ausgefüllt');
assert.strictEqual($form.find('input[name="wpStarttime"]').val(), 'starttime',
	'wpStarttime ist ausgefüllt');
assert.strictEqual($form.find('input[name="wpDiff"]').val(), 'wpDiff',
	'wpDiff ist vorhanden');
$form.remove();
//virtual outdent
});
//virtual outdent
});
})(jQuery, mediaWiki, mediaWiki.libs.templateEditor);
//</nowiki>