github-mirror/discourse
2
0
Fork 0
mirror of https://github.com/discourse/discourse.git synced 2025-05-23 12:31:06 +08:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Upgrade QUnit to latest version

Browse Source
This commit is contained in:
Robin Ward
2017-06-14 13:57:58 -04:00
parent 8ae445766f
commit cc525b1a8d
145 changed files with 7569 additions and 6763 deletions
Download Patch File Download Diff File Expand all files Collapse all files

133
test/javascripts/lib/utilities-test.js.es6
View File

@ -1,5 +1,4 @@
/* global Int8Array:true */
import { blank } from 'helpers/qunit-helpers';
import {
emailValid,
extractDomainFromUrl,
@ -17,68 +16,68 @@ import {
setCaretPosition
} from 'discourse/lib/utilities';
module("lib:utilities");
QUnit.module("lib:utilities");
test("emailValid", function() {
ok(emailValid('Bob@example.com'), "allows upper case in the first part of emails");
ok(emailValid('bob@EXAMPLE.com'), "allows upper case in the email domain");
QUnit.test("emailValid", assert => {
assert.ok(emailValid('Bob@example.com'), "allows upper case in the first part of emails");
assert.ok(emailValid('bob@EXAMPLE.com'), "allows upper case in the email domain");
});
test("extractDomainFromUrl", function() {
equal(extractDomainFromUrl('http://meta.discourse.org:443/random'), 'meta.discourse.org', "extract domain name from url");
equal(extractDomainFromUrl('meta.discourse.org:443/random'), 'meta.discourse.org', "extract domain regardless of scheme presence");
equal(extractDomainFromUrl('http://192.168.0.1:443/random'), '192.168.0.1', "works for IP address");
equal(extractDomainFromUrl('http://localhost:443/random'), 'localhost', "works for localhost");
QUnit.test("extractDomainFromUrl", assert => {
assert.equal(extractDomainFromUrl('http://meta.discourse.org:443/random'), 'meta.discourse.org', "extract domain name from url");
assert.equal(extractDomainFromUrl('meta.discourse.org:443/random'), 'meta.discourse.org', "extract domain regardless of scheme presence");
assert.equal(extractDomainFromUrl('http://192.168.0.1:443/random'), '192.168.0.1', "works for IP address");
assert.equal(extractDomainFromUrl('http://localhost:443/random'), 'localhost', "works for localhost");
});
var validUpload = validateUploadedFiles;
test("validateUploadedFiles", function() {
not(validUpload(null), "no files are invalid");
not(validUpload(undefined), "undefined files are invalid");
not(validUpload([]), "empty array of files is invalid");
QUnit.test("validateUploadedFiles", assert => {
assert.not(validUpload(null), "no files are invalid");
assert.not(validUpload(undefined), "undefined files are invalid");
assert.not(validUpload([]), "empty array of files is invalid");
});
test("uploading one file", function() {
QUnit.test("uploading one file", assert => {
sandbox.stub(bootbox, "alert");
not(validUpload([1, 2]));
ok(bootbox.alert.calledWith(I18n.t('post.errors.too_many_uploads')));
assert.not(validUpload([1, 2]));
assert.ok(bootbox.alert.calledWith(I18n.t('post.errors.too_many_uploads')));
});
test("new user cannot upload images", function() {
QUnit.test("new user cannot upload images", assert => {
Discourse.SiteSettings.newuser_max_images = 0;
Discourse.User.resetCurrent(Discourse.User.create());
sandbox.stub(bootbox, "alert");
not(validUpload([{name: "image.png"}]), 'the upload is not valid');
ok(bootbox.alert.calledWith(I18n.t('post.errors.image_upload_not_allowed_for_new_user')), 'the alert is called');
assert.not(validUpload([{name: "image.png"}]), 'the upload is not valid');
assert.ok(bootbox.alert.calledWith(I18n.t('post.errors.image_upload_not_allowed_for_new_user')), 'the alert is called');
});
test("new user cannot upload attachments", function() {
QUnit.test("new user cannot upload attachments", assert => {
Discourse.SiteSettings.newuser_max_attachments = 0;
sandbox.stub(bootbox, "alert");
Discourse.User.resetCurrent(Discourse.User.create());
not(validUpload([{name: "roman.txt"}]));
ok(bootbox.alert.calledWith(I18n.t('post.errors.attachment_upload_not_allowed_for_new_user')));
assert.not(validUpload([{name: "roman.txt"}]));
assert.ok(bootbox.alert.calledWith(I18n.t('post.errors.attachment_upload_not_allowed_for_new_user')));
});
test("ensures an authorized upload", function() {
QUnit.test("ensures an authorized upload", assert => {
sandbox.stub(bootbox, "alert");
not(validUpload([{ name: "unauthorized.html" }]));
ok(bootbox.alert.calledWith(I18n.t('post.errors.upload_not_authorized', { authorized_extensions: authorizedExtensions() })));
assert.not(validUpload([{ name: "unauthorized.html" }]));
assert.ok(bootbox.alert.calledWith(I18n.t('post.errors.upload_not_authorized', { authorized_extensions: authorizedExtensions() })));
});
test("staff can upload anything in PM", function() {
QUnit.test("staff can upload anything in PM", assert => {
const files = [{ name: "some.docx" }];
Discourse.SiteSettings.authorized_extensions = "jpeg";
Discourse.User.resetCurrent(Discourse.User.create({ moderator: true }));
sandbox.stub(bootbox, "alert");
not(validUpload(files));
ok(validUpload(files, { isPrivateMessage: true, allowStaffToUploadAnyFileInPm: true }));
assert.not(validUpload(files));
assert.ok(validUpload(files, { isPrivateMessage: true, allowStaffToUploadAnyFileInPm: true }));
});
var imageSize = 10 * 1024;
@ -94,19 +93,19 @@ var dummyBlob = function() {
}
};
test("allows valid uploads to go through", function() {
QUnit.test("allows valid uploads to go through", assert => {
Discourse.User.resetCurrent(Discourse.User.create());
Discourse.User.currentProp("trust_level", 1);
sandbox.stub(bootbox, "alert");
// image
var image = { name: "image.png", size: imageSize };
ok(validUpload([image]));
assert.ok(validUpload([image]));
// pasted image
var pastedImage = dummyBlob();
ok(validUpload([pastedImage]));
assert.ok(validUpload([pastedImage]));
not(bootbox.alert.calledOnce);
assert.not(bootbox.alert.calledOnce);
});
var testUploadMarkdown = function(filename) {
@ -119,27 +118,27 @@ var testUploadMarkdown = function(filename) {
});
};
test("getUploadMarkdown", function() {
ok(testUploadMarkdown("lolcat.gif") === '<img src="/uploads/123/abcdef.ext" width="100" height="200">');
ok(testUploadMarkdown("important.txt") === '<a class="attachment" href="/uploads/123/abcdef.ext">important.txt</a> (42 Bytes)\n');
QUnit.test("getUploadMarkdown", assert => {
assert.ok(testUploadMarkdown("lolcat.gif") === '<img src="/uploads/123/abcdef.ext" width="100" height="200">');
assert.ok(testUploadMarkdown("important.txt") === '<a class="attachment" href="/uploads/123/abcdef.ext">important.txt</a> (42 Bytes)\n');
});
test("isAnImage", function() {
QUnit.test("isAnImage", assert => {
_.each(["png", "jpg", "jpeg", "bmp", "gif", "tif", "tiff", "ico"], function(extension) {
var image = "image." + extension;
ok(isAnImage(image), image + " is recognized as an image");
ok(isAnImage("http://foo.bar/path/to/" + image), image + " is recognized as an image");
assert.ok(isAnImage(image), image + " is recognized as an image");
assert.ok(isAnImage("http://foo.bar/path/to/" + image), image + " is recognized as an image");
});
not(isAnImage("file.txt"));
not(isAnImage("http://foo.bar/path/to/file.txt"));
not(isAnImage(""));
assert.not(isAnImage("file.txt"));
assert.not(isAnImage("http://foo.bar/path/to/file.txt"));
assert.not(isAnImage(""));
});
test("avatarUrl", function() {
QUnit.test("avatarUrl", assert => {
var rawSize = getRawSize;
blank(avatarUrl('', 'tiny'), "no template returns blank");
equal(avatarUrl('/fake/template/{size}.png', 'tiny'), "/fake/template/" + rawSize(20) + ".png", "simple avatar url");
equal(avatarUrl('/fake/template/{size}.png', 'large'), "/fake/template/" + rawSize(45) + ".png", "different size");
assert.blank(avatarUrl('', 'tiny'), "no template returns blank");
assert.equal(avatarUrl('/fake/template/{size}.png', 'tiny'), "/fake/template/" + rawSize(20) + ".png", "simple avatar url");
assert.equal(avatarUrl('/fake/template/{size}.png', 'large'), "/fake/template/" + rawSize(45) + ".png", "different size");
});
var setDevicePixelRatio = function(value) {
@ -150,64 +149,64 @@ var setDevicePixelRatio = function(value) {
}
};
test("avatarImg", function() {
QUnit.test("avatarImg", assert => {
var oldRatio = window.devicePixelRatio;
setDevicePixelRatio(2);
var avatarTemplate = "/path/to/avatar/{size}.png";
equal(avatarImg({avatarTemplate: avatarTemplate, size: 'tiny'}),
assert.equal(avatarImg({avatarTemplate: avatarTemplate, size: 'tiny'}),
"<img alt='' width='20' height='20' src='/path/to/avatar/40.png' class='avatar'>",
"it returns the avatar html");
equal(avatarImg({avatarTemplate: avatarTemplate, size: 'tiny', title: 'evilest trout'}),
assert.equal(avatarImg({avatarTemplate: avatarTemplate, size: 'tiny', title: 'evilest trout'}),
"<img alt='' width='20' height='20' src='/path/to/avatar/40.png' class='avatar' title='evilest trout'>",
"it adds a title if supplied");
equal(avatarImg({avatarTemplate: avatarTemplate, size: 'tiny', extraClasses: 'evil fish'}),
assert.equal(avatarImg({avatarTemplate: avatarTemplate, size: 'tiny', extraClasses: 'evil fish'}),
"<img alt='' width='20' height='20' src='/path/to/avatar/40.png' class='avatar evil fish'>",
"it adds extra classes if supplied");
blank(avatarImg({avatarTemplate: "", size: 'tiny'}),
assert.blank(avatarImg({avatarTemplate: "", size: 'tiny'}),
"it doesn't render avatars for invalid avatar template");
setDevicePixelRatio(oldRatio);
});
test("allowsImages", function() {
QUnit.test("allowsImages", assert => {
Discourse.SiteSettings.authorized_extensions = "jpg|jpeg|gif";
ok(allowsImages(), "works");
assert.ok(allowsImages(), "works");
Discourse.SiteSettings.authorized_extensions = ".jpg|.jpeg|.gif";
ok(allowsImages(), "works with old extensions syntax");
assert.ok(allowsImages(), "works with old extensions syntax");
Discourse.SiteSettings.authorized_extensions = "txt|pdf|*";
ok(allowsImages(), "images are allowed when all extensions are allowed");
assert.ok(allowsImages(), "images are allowed when all extensions are allowed");
Discourse.SiteSettings.authorized_extensions = "json|jpg|pdf|txt";
ok(allowsImages(), "images are allowed when at least one extension is an image extension");
assert.ok(allowsImages(), "images are allowed when at least one extension is an image extension");
});
test("allowsAttachments", function() {
QUnit.test("allowsAttachments", assert => {
Discourse.SiteSettings.authorized_extensions = "jpg|jpeg|gif";
not(allowsAttachments(), "no attachments allowed by default");
assert.not(allowsAttachments(), "no attachments allowed by default");
Discourse.SiteSettings.authorized_extensions = "jpg|jpeg|gif|*";
ok(allowsAttachments(), "attachments are allowed when all extensions are allowed");
assert.ok(allowsAttachments(), "attachments are allowed when all extensions are allowed");
Discourse.SiteSettings.authorized_extensions = "jpg|jpeg|gif|pdf";
ok(allowsAttachments(), "attachments are allowed when at least one extension is not an image extension");
assert.ok(allowsAttachments(), "attachments are allowed when at least one extension is not an image extension");
Discourse.SiteSettings.authorized_extensions = ".jpg|.jpeg|.gif|.pdf";
ok(allowsAttachments(), "works with old extensions syntax");
assert.ok(allowsAttachments(), "works with old extensions syntax");
});
test("defaultHomepage", function() {
QUnit.test("defaultHomepage", assert => {
Discourse.SiteSettings.top_menu = "latest|top|hot";
equal(defaultHomepage(), "latest", "default homepage is the first item in the top_menu site setting");
assert.equal(defaultHomepage(), "latest", "default homepage is the first item in the top_menu site setting");
});
test("caretRowCol", () => {
QUnit.test("caretRowCol", assert => {
var textarea = document.createElement('textarea');
const content = document.createTextNode("01234\n56789\n012345");
textarea.appendChild(content);
@ -217,8 +216,8 @@ test("caretRowCol", () => {
setCaretPosition(textarea, setCaretPos);
const result = caretRowCol(textarea);
equal(result.rowNum, expectedRowNum, "returns the right row of the caret");
equal(result.colNum, expectedColNum, "returns the right col of the caret");
assert.equal(result.rowNum, expectedRowNum, "returns the right row of the caret");
assert.equal(result.colNum, expectedColNum, "returns the right col of the caret");
};
assertResult(0, 1, 0);
@ -228,4 +227,4 @@ test("caretRowCol", () => {
assertResult(14, 3, 2);
document.body.removeChild(textarea);
});
});