Software: Apache/2.2.16 (Debian). PHP/5.3.3-7+squeeze19 uname -a: Linux mail.tri-specialutilitydistrict.com 2.6.32-5-amd64 #1 SMP Tue May 13 16:34:35 UTC uid=33(www-data) gid=33(www-data) groups=33(www-data) Safe-mode: OFF (not secure) /usr/lib/python2.6/dist-packages/nevow/js/Nevow/Athena/Tests/ drwxr-xr-x | |
| Viewing file: Select action/file-type: // import Divmod.Runtime
// import Nevow.Athena
Nevow.Athena.Tests.WidgetInitializerArguments = Nevow.Athena.Test.TestCase.subclass('Nevow.Athena.Tests.WidgetInitializerArguments');
Nevow.Athena.Tests.WidgetInitializerArguments.methods(
function __init__(self, node) {
Nevow.Athena.Tests.WidgetInitializerArguments.upcall(self, '__init__', node);
self.args = [];
for (var i = 2; i < arguments.length; ++i) {
self.args.push(arguments[i]);
}
},
function test_widgetInitializationArguments(self) {
return self.callRemote('test', self.args);
});
Nevow.Athena.Tests.CallRemoteTestCase = Nevow.Athena.Test.TestCase.subclass('Nevow.Athena.Tests.CallRemoteTestCase');
Nevow.Athena.Tests.CallRemoteTestCase.methods(
/**
* Test that calling a method which is not exposed properly results in a
* failed Deferred.
*/
function test_invalidRemoteMethod(self) {
return self.assertFailure(
self.callRemote("noSuchMethod"),
[Nevow.Athena.NoSuchMethod]);
});
Nevow.Athena.Tests.ClientToServerArgumentSerialization = Nevow.Athena.Test.TestCase.subclass('Nevow.Athena.Tests.ClientToServerArgumentSerialization');
Nevow.Athena.Tests.ClientToServerArgumentSerialization.methods(
function test_clientToServerArgumentSerialization(self) {
var L = [1, 1.5, 'Hello world'];
var O = {'hello world': 'object value'};
return self.callRemote('test', 1, 1.5, 'Hello world', L, O);
});
Nevow.Athena.Tests.ClientToServerResultSerialization = Nevow.Athena.Test.TestCase.subclass('Nevow.Athena.Tests.ClientToServerResultSerialization');
Nevow.Athena.Tests.ClientToServerResultSerialization.methods(
function test_clientToServerResultSerialization(self) {
var L = [1, 1.5, 'Hello world'];
var O = {'hello world': 'object value'};
var d = self.callRemote('test', 1, 1.5, 'Hello world', L, O);
d.addCallback(function(result) {
self.assertEquals(result[0], 1);
self.assertEquals(result[1], 1.5);
self.assertEquals(result[2], 'Hello world');
self.assertEquals(result[3][0], 1);
self.assertEquals(result[3][1], 1.5);
self.assertEquals(result[3][2], 'Hello world');
self.assertEquals(result[4]['hello world'], 'object value');
});
return d;
});
Nevow.Athena.Tests.ExceptionFromServer = Nevow.Athena.Test.TestCase.subclass('Nevow.Athena.Tests.ExceptionFromServer');
Nevow.Athena.Tests.ExceptionFromServer.methods(
function test_exceptionFromServer(self) {
var d;
var s = 'This exception should appear on the client.';
d = self.callRemote('testSync', s);
d.addCallbacks(
function(result) {
self.fail('Erroneously received a result: ' + result);
},
function(f) {
var idx = f.error.message.indexOf(s);
if (idx == -1) {
self.fail('Did not find expected message in error message: ' + f.error.message);
}
});
return d;
});
Nevow.Athena.Tests.JSONRoundtrip = Nevow.Athena.Test.TestCase.subclass('Nevow.Athena.Tests.JSONRoundtrip');
Nevow.Athena.Tests.JSONRoundtrip.methods(
function test_jsonRoundTrip(self) {
return self.callRemote('test');
},
function identity(self, value) {
return value;
});
Nevow.Athena.Tests.AsyncExceptionFromServer = Nevow.Athena.Test.TestCase.subclass('Nevow.Athena.Tests.AsyncExceptionFromServer');
Nevow.Athena.Tests.AsyncExceptionFromServer.methods(
function test_asyncExceptionFromServer(self) {
var d;
var s = 'This exception should appear on the client.';
d = self.callRemote('testAsync', s);
d.addCallbacks(
function(result) {
self.fail('Erroneously received a result: ' + result);
},
function(f) {
var idx = f.error.message.indexOf(s);
if (idx == -1) {
self.fail('Did not find expected message in error message: ' + f.error.message);
}
});
return d;
});
Nevow.Athena.Tests.ExceptionFromClient = Nevow.Athena.Test.TestCase.subclass('Nevow.Athena.Tests.ExceptionFromClient');
Nevow.Athena.Tests.ExceptionFromClient.methods(
function test_exceptionFromClient(self) {
var d;
d = self.callRemote('loopbackError');
d.addCallbacks(
function (result) {
},
function (f) {
self.fail('Received unexpected exception: ' + f.error.message);
});
return d;
},
function generateError(self) {
throw new Error('This is a test exception');
});
Nevow.Athena.Tests.AsyncExceptionFromClient = Nevow.Athena.Test.TestCase.subclass('Nevow.Athena.Tests.AsyncExceptionFromClient');
Nevow.Athena.Tests.AsyncExceptionFromClient.methods(
function test_asyncExceptionFromClient(self) {
var d;
d = self.callRemote('loopbackError');
d.addCallbacks(
function (result) {
if (!result) {
self.fail('Received incorrect Javascript exception or no traceback.');
}
},
function (f) {
self.fail('Received unexpected exception: ' + f.error.message);
});
return d;
},
function generateError(self) {
return Divmod.Defer.fail(Error('This is a deferred test exception'));
});
/**
* Helper class used to verify that a Python object which provides
* nevow.inevow.IAthenaTransportable can specify a JavaScript class which
* will be instantiated to represent it in the browser.
*/
Nevow.Athena.Tests.CustomTransportable = Divmod.Class.subclass(
'Nevow.Athena.Tests.CustomTransportable');
Nevow.Athena.Tests.CustomTransportable.methods(
function __init__(self, firstArgument, secondArgument, thirdArgument) {
self.firstArgument = firstArgument;
self.secondArgument = secondArgument;
self.thirdArgument = thirdArgument;
});
Nevow.Athena.Tests.ServerToClientArgumentSerialization = Nevow.Athena.Test.TestCase.subclass('Nevow.Athena.Tests.ServerToClientArgumentSerialization');
Nevow.Athena.Tests.ServerToClientArgumentSerialization.methods(
function test_serverToClientArgumentSerialization(self) {
return self.callRemote('test');
},
function reverse(self, anInteger, aFloat, aString, anObject, aCustomObject) {
self.assertEquals(anInteger, 1);
self.assertEquals(aFloat, 1.5);
self.assertEquals(aString, 'hello');
self.assertEquals(anObject['world'], 'value');
self.failUnless(aCustomObject instanceof Nevow.Athena.Tests.CustomTransportable);
self.assertEquals(aCustomObject.firstArgument, "Hello");
self.assertEquals(aCustomObject.secondArgument, 5);
self.assertEquals(aCustomObject.thirdArgument, "world");
});
Nevow.Athena.Tests.ServerToClientResultSerialization = Nevow.Athena.Test.TestCase.subclass('Nevow.Athena.Tests.ServerToClientResultSerialization');
Nevow.Athena.Tests.ServerToClientResultSerialization.methods(
function test_serverToClientResultSerialization(self) {
return self.callRemote('test');
},
function reverse(self) {
return [1, 1.5, 'hello', {'world': 'value'}];
});
Nevow.Athena.Tests.WidgetInATable = Nevow.Athena.Test.TestCase.subclass('Nevow.Athena.Tests.WidgetInATable');
Nevow.Athena.Tests.WidgetInATable.methods(
function test_widgetInATable(self) {
// Nothing to do
});
Nevow.Athena.Tests.WidgetIsATable = Nevow.Athena.Test.TestCase.subclass('Nevow.Athena.Tests.WidgetIsATable');
Nevow.Athena.Tests.WidgetIsATable.methods(
function test_widgetIsATable(self) {
// Nothing to do
});
Nevow.Athena.Tests.ChildParentRelationshipTest = Nevow.Athena.Test.TestCase.subclass('Nevow.Athena.Tests.ChildParentRelationshipTest');
Nevow.Athena.Tests.ChildParentRelationshipTest.methods(
function checkParent(self, proposedParent) {
self.assertEquals(self.widgetParent, proposedParent);
},
function test_childParentRelationship(self) {
var deferredList = function(finalDeferred, counter) {
if (counter == 0) {
finalDeferred.callback(null);
}
var callback = function(ignored) {
counter -= 1;
Divmod.log('test', 'One more down, ' + counter + ' to go.');
if (counter == 0) {
finalDeferred.callback(null);
}
};
return callback;
};
var result = self.callRemote('getChildCount');
result.addCallback(function(count) {
Divmod.log('test', 'Discovered I have ' + count + ' children');
var d = new Divmod.Defer.Deferred();
d.addCallback(function() { self.node.style.border = 'thin solid green'; });
var cb = deferredList(d, count);
self.assertEquals(self.childWidgets.length, count);
for (var i = 0; i < self.childWidgets.length; i++) {
var childWidget = self.childWidgets[i];
childWidget.checkParent(self);
childWidget.test_childParentRelationship().addCallback(cb).addErrback(function(err) { d.errback(err); });
}
return d;
});
return result;
});
Nevow.Athena.Tests.AutomaticClass = Nevow.Athena.Test.TestCase.subclass('Nevow.Athena.Tests.AutomaticClass');
Nevow.Athena.Tests.AutomaticClass.methods(
function test_automaticClass(self) {
// Nothing to do here
});
Nevow.Athena.Tests.ImportBeforeLiteralJavaScript = Nevow.Athena.Test.TestCase.subclass('Nevow.Athena.Tests.ImportBeforeLiteralJavaScript');
Nevow.Athena.Tests.ImportBeforeLiteralJavaScript.methods(
function test_importBeforeLiteralJavaScript(self) {
self.assertEquals(importBeforeLiteralJavaScriptResult, false);
});
Nevow.Athena.Tests.AthenaHandler = Nevow.Athena.Test.TestCase.subclass('Nevow.Athena.Tests.AthenaHandler');
Nevow.Athena.Tests.AthenaHandler.methods(
/**
* Call the given object if it is a function. eval() it if it is a string.
*/
function _execute(self, thisObject, stringOrFunction) {
if (typeof stringOrFunction === 'string') {
return (
function() {
return eval(stringOrFunction);
}).call(thisObject);
} else if (typeof stringOrFunction === 'function') {
return stringOrFunction.call(thisObject);
} else {
self.fail(
"_execute() given something that is neither a " +
"string nor a function: " + stringOrFunction);
}
},
function test_athenaHandler(self) {
self.handled = false;
var button = self.node.getElementsByTagName('button')[0];
var onclick = button.onclick;
self.assertEquals(self._execute(button, onclick), false);
self.assertEquals(self.handled, true);
},
function handler(self, evt) {
self.handled = true;
return false;
});
/**
* Simple widget to be dynamically instantiated for testing nodeInserted
* behaviour.
*/
Nevow.Athena.Tests.NodeInsertedHelper = Nevow.Athena.Widget.subclass('Nevow.Athena.Tests.NodeInsertedHelper');
Nevow.Athena.Tests.NodeInsertedHelper.methods(
/**
* Detect whether nodeInserted is called; Athena should do this when (and
* only when) instantiating us statically.
*/
function nodeInserted(self) {
self.inserted = true;
});
Nevow.Athena.Tests.NodeLocation = Nevow.Athena.Test.TestCase.subclass('Nevow.Athena.Tests.NodeLocation');
Nevow.Athena.Tests.NodeLocation.methods(
function test_firstNodeByAttribute(self) {
var node = self.childWidgets[0].firstNodeByAttribute("class", "foo");
self.assertEquals(node.className, "foo");
self.assertEquals(node.tagName.toLowerCase(), "label");
},
/**
* Test that nodeById finds the node.
*/
function test_nodeById(self) {
var node = self.childWidgets[0].childWidgets[0].nodeById('username');
self.assertEquals(node.className, 'bar');
self.assertEquals(node.tagName.toLowerCase(), 'input');
},
/**
* Test that nodeById finds the node in the parent widget, not the child
* widget.
*/
function test_nodeByIdParent(self) {
var node = self.childWidgets[0].nodeById('username');
self.assertEquals(node.className, 'foo');
self.assertEquals(node.tagName.toLowerCase(), 'input');
},
/**
* Test that ID mangling mangles label.for as well as id attributes. Label
* and for must be equal.
*/
function test_matchingLabelForAndId(self) {
var label = self.childWidgets[0].firstNodeByAttribute("class", "foo");
var labelForAttribute = Divmod.Runtime.theRuntime.getAttribute(label, "for");
var input = self.childWidgets[0].nodeById('username');
self.assertEquals(labelForAttribute, input["id"]);
},
/**
* Test that nodeById throws NodeNotFound when the node cannot be located.
*/
function test_nodeByIdNotFound(self) {
var _find = function () { return self.childWidgets[0].nodeById('nonexistent'); };
self.assertThrows(Divmod.Runtime.NodeNotFound, _find);
},
function addDynamicWidget(self, child, method) {
var d = child.callRemote(method);
d.addCallback(
function (widgetInfo) {
return child.addChildWidgetFromWidgetInfo(widgetInfo);
});
return d;
},
/**
* Test that nodeById is able to locate nodes in a dynamically instantiated
* widget that has not yet been added as a child somewhere in the browser
* document.
*/
function test_nodeByIdInDynamicOrphan(self) {
var child = self.childWidgets[1];
var d = self.addDynamicWidget(child, 'getDynamicWidget');
d.addCallback(
function (widget) {
var node = widget.nodeById('username');
self.assertEquals(node.className, 'foo');
self.assertEquals(node.tagName.toLowerCase(), 'input');
});
return d;
},
/**
* Test that nodeById is able to locate nodes in a dynamically instantiated
* widget that has already been added as a child somewhere in the browser
* document.
*/
function test_nodeByIdInDynamicChild(self) {
var child = self.childWidgets[1];
var d = self.addDynamicWidget(child, 'getDynamicWidget');
d.addCallback(
function (widget) {
child.node.appendChild(widget.node);
var node = widget.nodeById('username');
self.assertEquals(node.className, 'foo');
self.assertEquals(node.tagName.toLowerCase(), 'input');
});
return d;
},
function test_nodeByIdNotFoundInDynamicOrphan(self) {
var child = self.childWidgets[1];
var d = self.addDynamicWidget(child, 'getDynamicWidget');
d.addCallback(
function (widget) {
var _find = function () { return widget.nodeById('nonexistent'); };
self.assertThrows(Divmod.Runtime.NodeNotFound, _find);
});
return d;
},
/**
* Detect whether nodeInserted is called; Athena should do this when (and
* only when) instantiating us statically.
*/
function nodeInserted(self) {
self.inserted = true;
},
/**
* Test that nodeInserted is called on a widget that is statically
* instantiated.
*/
function test_staticWidget(self) {
self.assertEqual(self.inserted, true);
},
/**
* Test that nodeInserted is *not* called on a widget that is dynamically
* instantiated.
*/
function test_dynamicWidget(self) {
var child = self.childWidgets[1];
var d = self.addDynamicWidget(child, 'getNodeInsertedHelper');
d.addCallback(
function (widget) {
self.assertNotEqual(widget.inserted, true);
});
return d;
});
Nevow.Athena.Tests.DynamicWidgetClass = Nevow.Athena.Widget.subclass('Nevow.Athena.Tests.DynamicWidgetClass');
Nevow.Athena.Tests.DynamicWidgetClass.methods(
function someMethod(self) {
/*
* Do something that hits our Fragment on the server to make sure we
* can.
*/
return self.callRemote('someMethod');
});
/**
* Test that retrieving several LiveFragments from the server using a
* method call returns something which can be passed to
* L{Nevow.Athena.Widget.getDynamicWidgetInfo} to add new widgets to the
* page.
*/
Nevow.Athena.Tests.DynamicWidgetInstantiation = Nevow.Athena.Test.TestCase.subclass('Nevow.Athena.Tests.DynamicWidgetInstantiation');
Nevow.Athena.Tests.DynamicWidgetInstantiation.methods(
/**
* Test that a s->c C{callRemote} can pass a widget.
*
* In other words, test that this python code:
* C{self.callRemote('takeWidget', widget)} works correctly.
*/
function test_childWidgetAsArgument(self) {
// ask the server to make a remote call
var d = self.callRemote("getDynamicWidgetLater");
d.addCallback(
function (ignored) {
var d2 = self._childWidgetAsArgumentDeferred.addCallback(
function (childWidget) {
self.assertEqual(childWidget.widgetParent, self);
var d3 = childWidget.callRemote('someMethod');
d3.addCallback(
function (ret) {
self.assertEqual(ret, 'foo');
});
return d3;
});
return d2;
});
return d;
},
/**
* A callable which the server can C{callRemote}, passing a widget as an
* argument. C{widgetinfo} is the marshalled form of the widget.
*
* @return null because we cannot, at present, serialize widgets from
* client to server.
*/
function sendWidgetAsArgument(self, widgetinfo) {
self._childWidgetAsArgumentDeferred =
self.addChildWidgetFromWidgetInfo(widgetinfo);
return null;
},
/**
* Test that widgets with non-XHTML namespaces can be sent server to
* client.
*
* The widget returned by the server should be rebuilt with the same
* C{namespaceURI} it was given at render time.
*/
function test_nonXHTMLWidgetReturn(self) {
var result = self.callRemote("getNonXHTMLWidget");
result.addCallback(
function _(info) {
return self.addChildWidgetFromWidgetInfo(info)
});
result.addCallback(
function (childWidget) {
self.assertEqual(childWidget.widgetParent, self);
self.assertEqual(childWidget.node.namespaceURI,
'http://www.w3.org/2000/svg');
});
return result;
},
/**
* Test the API for adding a widget based on an ID, class name, and
* __init__ arguments to an existing page.
*/
function test_addChildWidgetFromComponents(self) {
var widgetID;
var widgetClass;
/*
* Get a widget from the server
*/
var result = self.callRemote('getDynamicWidgetInfo');
result.addCallback(
function(widgetInfo) {
widgetID = widgetInfo.id;
widgetClass = widgetInfo.klass;
/*
* Server isn't going to give us any markup because markup is
* fugly. So, construct the widget's root node ourselves. It
* still needs to have all the special attributes for anything
* to work right.
*/
return self._addChildWidgetFromComponents(
[], [], widgetID, widgetClass, [], [],
'<span xmlns="http://www.w3.org/1999/xhtml" id="athena:' +
widgetID + '" class="' + widgetClass + '" />');
});
result.addCallback(
function(childWidget) {
self.assertEqual(Nevow.Athena.Widget.get(childWidget.node), childWidget);
self.assertEqual(childWidget.widgetParent, self);
self.assertEqual(self.childWidgets[self.childWidgets.length - 1], childWidget);
return childWidget.someMethod();
});
result.addCallback(
function(methodResult) {
self.assertEqual(methodResult, 'foo');
});
return result;
},
/**
* Test the API for adding a widget based on a messy pile of data.
*/
function test_addChildWidgetFromWidgetInfo(self) {
var result = self.callRemote('getDynamicWidget');
result.addCallback(
function(widget) {
return self.addChildWidgetFromWidgetInfo(widget);
});
result.addCallback(
function(widget) {
self.assertEqual(Nevow.Athena.Widget.get(widget.node), widget);
self.assertEqual(widget.widgetParent, self);
self.assertEqual(self.childWidgets[self.childWidgets.length - 1], widget);
return widget.someMethod();
});
result.addCallback(
function(methodResult) {
self.assertEqual(methodResult, 'foo');
});
return result;
},
/**
* Verify that removeChildWidget sets the specified widget's parent to null
* and removes it from the parent's children array.
*/
function test_removeChildWidget(self) {
var result = self.callRemote('getDynamicWidget');
result.addCallback(
function(widgetInfo) {
return self.addChildWidgetFromWidgetInfo(widgetInfo);
});
result.addCallback(
function(widget) {
self.removeChildWidget(widget);
self.assertEqual(widget.widgetParent, null);
for (var i = 0; i < self.childWidgets.length; ++i) {
self.assertNotEqual(self.childWidgets[i], widget);
}
});
return result;
},
/**
* Verify that removeChildWidget throws the appropriate error when an
* attempt is made to remove a child from a widget which is not its parent.
*/
function test_invalidRemoveChildWidget(self) {
self.assertThrows(
Nevow.Athena.NoSuchChild,
function() {
self.removeChildWidget({});
});
},
/**
* Test that removeAllChildWidgets leaves the child widget list empty
* and ensures that the removed widgets have a null parent.
*/
function test_removeAllChildWidgets(self) {
var result = self.callRemote('getDynamicWidget');
result.addCallback(
function(widget) {
return self.addChildWidgetFromWidgetInfo(widget);
});
result.addCallback(
function(widget) {
self.removeAllChildWidgets();
self.assertEqual(widget.widgetParent, null);
self.assertEqual(self.childWidgets.length, 0);
});
return result;
},
/**
* Helper for L{test_detachOrphan} and L{test_serverSideDetachOrphan}.
*
* @param detach: A one-argument callable which will be invoked with a
* widget and should detach it in whatever way is being tested and return a
* Deferred which fires when the detach has been completed.
*/
function _detachTest(self, detach) {
var result = self.callRemote('getAndRememberDynamicWidget');
result.addCallback(
function(widgetInfo) {
return self.addChildWidgetFromWidgetInfo(widgetInfo);
});
result.addCallback(
function(widget) {
/*
* Orphan it.
*/
self.removeChildWidget(widget);
/*
* Sanity check
*/
self.failUnless(
widget.objectID in Nevow.Athena.Widget._athenaWidgets);
/*
* Actually get rid of it.
*/
var d = detach(widget);
d.addCallback(
function(ignored) {
return widget;
});
return d
});
result.addCallback(
function(widget) {
/*
* Locally, athena should not be tracking or referencing this
* object any more.
*/
self.failIf(
widget.objectID in Nevow.Athena.Widget._athenaWidgets);
/*
* The server should also have forgotten about it.
*/
return self.callRemote("assertSavedWidgetRemoved");
});
return result;
},
/**
* Verify that a widget with no parent can be disassociated from its
* server-side component and removed from Athena's tracking.
*/
function test_detachOrphan(self) {
return self._detachTest(
function(widget) {
return widget.detach();
});
},
/**
* Similar to L{test_detachOrphan}, but perform the detach using the
* server-side API.
*/
function test_serverSideDetachOrphan(self) {
return self._detachTest(
function(widget) {
return self.callRemote('detachSavedDynamicWidget');
});
},
/**
* Helper for L{test_detachedCallback} and L{test_remoteDetachedCallback}.
*
* @param detach: A one-argument callable which will be invoked with a
* widget and should detach it in whatever way is being tested and return a
* Deferred which fires when the detach has been completed.
*/
function _detachedCallbackTest(self, detach) {
var detachCalls = [];
var result = self.callRemote('getAndRememberDynamicWidget');
result.addCallback(
function(widgetInfo) {
return self.addChildWidgetFromWidgetInfo(widgetInfo);
});
result.addCallback(
function(widget) {
/*
* Make sure we notice the detached callback.
*/
function detached() {
var id = widget.objectID;
var notWidget = Nevow.Athena.Widget._athenaWidgets[id];
detachCalls.push([widget.widgetParent, notWidget]);
};
widget.detached = detached;
/*
* Do the detach.
*/
return detach(widget);
});
result.addCallback(
function(ignored) {
self.assertEqual(detachCalls.length, 1);
self.assertEqual(detachCalls[0][0], null);
self.assertEqual(detachCalls[0][1], undefined);
});
return result;
},
/**
* Verify that the C{detached} widget callback is invoked when a widget is
* detached from this side of the connection.
*/
function test_detachedCallback(self) {
return self._detachedCallbackTest(
function(widget) {
return widget.detach();
});
},
function _testDetachWithChildren(self, detach) {
var parent = null;
var child = null;
var result = self.callRemote('getAndSaveDynamicWidgetWithChild');
result.addCallback(
function(widgetInfo) {
return self.addChildWidgetFromWidgetInfo(widgetInfo);
});
result.addCallback(
function(widget) {
parent = widget;
child = widget.childWidgets[0];
return widget.detach();
});
result.addCallback(
function(ignored) {
self.assertEqual(parent.childWidgets.length, 0);
self.assertEqual(parent.widgetParent, null);
self.assertEqual(child.widgetParent, null);
var widgets = Nevow.Athena.Widget._athenaWidgets;
self.failIf(parent.objectID in widgets);
self.failIf(child.objectID in widgets);
});
return result;
},
/**
* Like C{test_detach}, but cover the case where a detached widget has
* children itself. Verify that the children are detached as well.
*/
function test_detachWithChildren(self) {
return self._testDetachWithChildren(
function(widget) {
return widget.detach();
});
},
/**
* Like C{test_detach}, but cover the case where a detached widget has
* children itself. Verify that the children are detached as well.
*/
function test_serverSideDetachWithChildren(self) {
return self._testDetachWithChildren(
function(widget) {
return widget.callRemote('detachSavedDynamicWidget');
});
},
/**
* Test dynamic instantiation of a widget defined in a module which has not
* yet been imported.
*/
function test_dynamicImportWidget(self) {
/*
* Sanity check
*/
self.assertEqual(Nevow.Athena.Tests.Resources, undefined);
var result = self.callRemote("getWidgetWithImports");
result.addCallback(
function(widgetInfo) {
return self.addChildWidgetFromWidgetInfo(widgetInfo);
});
result.addCallback(
function(widget) {
self.failUnless(widget instanceof Nevow.Athena.Tests.Resources.ImportWidget);
});
return result;
}
);
/**
* Test that calling Widget.get() on a node which is not part of any Widget
* throws an error.
*/
Nevow.Athena.Tests.GettingWidgetlessNodeRaisesException = Nevow.Athena.Test.TestCase.subclass('Nevow.Athena.Tests.GettingWidgetlessNodeRaisesException');
Nevow.Athena.Tests.GettingWidgetlessNodeRaisesException.methods(
function test_gettingWidgetlessNodeRaisesException(self) {
var result;
var threw;
try {
result = Nevow.Athena.Widget.get(document.head);
threw = false;
} catch (err) {
threw = true;
}
if (!threw) {
self.fail("No error thrown by Widget.get() - returned " + result + " instead.");
}
});
Nevow.Athena.Tests.RemoteMethodErrorShowsDialog = Nevow.Athena.Test.TestCase.subclass('RemoteMethodErrorShowsDialog');
Nevow.Athena.Tests.RemoteMethodErrorShowsDialog.methods(
function test_remoteMethodErrorShowsDialog(self) {
var getDialogs = function() {
return Nevow.Athena.NodesByAttribute(
document.body,
"class",
"athena-error-dialog-" + Nevow.Athena.athenaIDFromNode(self.node));
}
return self.callRemote("raiseValueError").addErrback(
function(err) {
/* we added the errback before the setTimeout()
in callRemote() fired, so it won't get the error */
self.assertEquals(getDialogs().length, 0);
var D = self.callRemote("raiseValueError");
/* we make another deferred to return from this method
because the test machinery will add callbacks to D,
which will get run before athena adds the errback,
resulting in a test failure */
var waitD = Divmod.Defer.Deferred();
/* setTimeout() the callback-adding, because we want
the callback to run after athena has added the
error dialog errback to the callRemote() deferred */
setTimeout(function() {
D.addCallback(
function() {
var dialogs = getDialogs();
if(dialogs.length == 1) {
document.body.removeChild(dialogs[0]);
waitD.callback(null);
} else {
waitD.errback(
new Error("expected 1 dialog, got " + dialogs.length));
}
});
}, 0);
return waitD;
});
});
Nevow.Athena.Tests.DelayedCallTests = Nevow.Athena.Test.TestCase.subclass('Nevow.Athena.Tests.DelayedCallTests');
Nevow.Athena.Tests.DelayedCallTests.methods(
/**
* Verify correct behavior in the trivial case of a call scheduled for a
* short period of time in the future.
*/
function test_callLater(self) {
var result = Divmod.Defer.Deferred();
var finished = false;
function delayed() {
finished = true;
result.callback(null);
};
self.callLater(0, delayed);
self.failIf(finished);
return result;
},
/**
* Verify that when a DelayedCall is cancelled, it does not run.
*/
function test_cancelDelayedCall(self) {
var finished = false;
function delayed() {
finished = true;
};
var call = self.callLater(0, delayed);
call.cancel();
/*
* Let a little time pass and then make sure the above call never ran.
*/
var result = Divmod.Defer.Deferred();
var counter = 3;
function check() {
if (counter > 0) {
counter -= 1;
self.callLater(0, check);
return;
}
try {
self.failIf(finished);
} catch (err) {
result.errback(err);
return;
}
result.callback(null);
};
self.callLater(0, check);
return result;
},
/**
* Verify that three calls separately scheduled for different times run in
* the appropriate order.
*/
function test_callLaterOrdering(self) {
var result = Divmod.Defer.Deferred();
var calls = [];
function first() {
calls.push("first");
};
function second() {
calls.push("second");
};
function third() {
calls.push("third");
result.callback(null);
};
/*
* This also happens to serve as a test for the seconds/milliseconds
* conversion code, since sub-millisecond fractional times are
* collapsed to 0 (at least by Firefox 1.5).
*/
self.callLater(0.02, second);
self.callLater(0.03, third);
self.callLater(0.01, first);
result.addCallback(
function(ignored) {
self.assertEqual(calls.length, 3);
self.assertEqual(calls[0], "first");
self.assertEqual(calls[1], "second");
self.assertEqual(calls[2], "third");
});
return result;
});
Nevow.Athena.Tests.DynamicStylesheetFetching = Nevow.Athena.Test.TestCase.subclass('Nevow.Athena.Tests.DynamicStylesheetFetching');
/**
* Tests for CSS module fetching when dynamic widget instantiation is
* involved.
*/
Nevow.Athena.Tests.DynamicStylesheetFetching.methods(
/**
* C{<link>} tags should appear in the document's C{<head>} when a widget
* with CSS dependencies is dynamically instantiated.
*/
function test_dynamicInstantiation(self) {
var D = self.callRemote('getWidgetWithCSSDependencies');
var cssURLs;
D.addCallback(
function(t) {
cssURLs = t[1];
return self.addChildWidgetFromWidgetInfo(t[0]);
});
D.addCallback(
function(widget) {
var head = document.getElementsByTagName('head')[0];
var links = head.getElementsByTagName('link');
var stylesheets = [];
for(var i = 0; i < links.length; i++) {
if(links[i].getAttribute('rel') === 'stylesheet'
&& links[i].getAttribute('type') === 'text/css') {
stylesheets.push(links[i].getAttribute('href'));
}
}
self.assertEqual(stylesheets.length, cssURLs.length);
for(var i = 0; i < cssURLs.length; i++) {
self.assertEqual(stylesheets[i], cssURLs[i]);
}
});
return D;
});
|
:: Command execute :: | |
--[ c99shell v. 2.0 [PHP 7 Update] [25.02.2019] maintained by KaizenLouie | C99Shell Github | Generation time: 0.009 ]-- |