You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
225 lines
7.0 KiB
225 lines
7.0 KiB
dojo.provide("util.docscripts.tests.basic"); |
|
(function(){ |
|
|
|
var url = dojo.moduleUrl("util.docscripts", "dumpObj.php") + ""; |
|
function getdata(file){ |
|
|
|
var r; |
|
dojo.xhrGet({ |
|
url: url + "?f=" + file, |
|
sync: true, |
|
handleAs:"json", |
|
handle: function(response){ |
|
r = response; |
|
} |
|
}); |
|
return r; |
|
|
|
} |
|
|
|
var docs; |
|
function getmember(key, obj){ |
|
obj = obj || docs; |
|
return obj[key]; |
|
} |
|
|
|
doh.register("doctests.basic", [ |
|
|
|
function actual_fetching(t){ |
|
docs = getdata("util/docscripts/tests/simple.js"); |
|
t.t(docs); |
|
t.t(typeof docs == "object"); |
|
t.is(docs["#provides"], "util.docscripts.tests.simple", "provide() object found"); |
|
t.is(docs["#resource"], "docscripts/tests/simple.js", "filename expansion"); |
|
t.t(docs["util.docscripts.tests"], "provide() expansion"); |
|
}, |
|
|
|
function simple_requires(t){ |
|
t.t(dojo.isArray(docs['#requires'][0]), "populated require"); |
|
t.t(~dojo.indexOf(docs["#requires"][0], "dojo.cookie"), "found cookie require"); |
|
}, |
|
|
|
function module_level_docs(t){ |
|
var fb = getmember("util.docscripts.tests.simple"); |
|
t.is("Module level summary", fb.summary, "summary from psuedo on module obj"); |
|
}, |
|
|
|
function basic_class(t){ |
|
|
|
var fb = getmember("dojo.FooBar"); |
|
|
|
t.t(fb, "dojo.FooBar docs exist"); |
|
t.t(fb.classlike, "classlike thinger found"); |
|
t.is("A Class", fb.summary, "picked up summary from post-decalre docs"); |
|
t.is("Function", fb.type, "inference"); |
|
t.is("A Class description", fb.description, "description from post-declare docs"); |
|
|
|
t.t(dojo.isArray(fb.examples), "found examples"); |
|
t.is(1, fb.examples.length, "found one example exactly"); |
|
|
|
var fbc = getmember("dojo.FooBar.constructor"); |
|
t.is(fbc.prototype, "dojo.FooBar", "prototype binding"); |
|
t.is(fbc.parameters.args.name, fb.parameters.args.name, "params from constructor implied on class"); |
|
|
|
var mf = getmember("dojo.FooBar.memberFn"); |
|
t.t(mf, "member function picked out of declaration"); |
|
|
|
var params = mf.parameters; |
|
t.is("String", params.a.type); |
|
t.f(params.b.optional); |
|
t.is("String", params.b.type); |
|
t.f(params.b.optional); |
|
t.is("Boolean", params.c.type); |
|
t.t(params.c.optional, "last arg optional"); |
|
t.is("Integer", mf.returns); |
|
t.is("A member function", mf.summary); |
|
|
|
}, |
|
|
|
function inherited_class(t){ |
|
var fb2 = getmember("dojo.FooBar2"); |
|
t.t(fb2); |
|
// TODO: |
|
// check fb2.chains for dojo.FooBar |
|
// check fb2.inheritance |
|
// FIXME: |
|
// what is chains v prototype |
|
}, |
|
|
|
function mixin_docs(t){ |
|
var mv = getmember("dojo.mixedValue"); |
|
t.is("External doc block, mixed", mv.summary, "summary found for mixed value"); |
|
t.is("Integer", mv.type, "type infered from mixed value"); |
|
t.is("dojo", mv.attached, "alias lookup in d.mixin"); |
|
|
|
var mf = getmember("dojo.mixedFunction"); |
|
t.is("dojo", mf.attached, "alias lookup in d.mixin"); |
|
t.is("Integer", mf.returns, "returns from return line"); |
|
t.is("From mixin", mf.summary, "basic summary"); |
|
t.is("a", mf.parameters.a.name, "parameter picked up"); |
|
t.t(mf.parameters.a.optional, "param is optional"); |
|
t.is(mf.parameters.a.summary, "Some number or not", "parameter description picked up"); |
|
}, |
|
|
|
function basic_function(t){ |
|
|
|
var fb = getmember("dojo.thisIsAtestFunction"); |
|
t.t(fb, "testFunction docs exist"); |
|
t.is("Testing a function", fb.summary); |
|
t.is("String", fb.returns, "return value determined"); |
|
t.is("Testing a string parameter", fb.parameters.a.summary, "parameter summary picked out"); |
|
}, |
|
|
|
function testfunction2(t){ |
|
var tf = getmember("dojo.testFunction2"); |
|
t.is("Simple summary", tf.summary); |
|
t.is("Simple Description.\nOn Multiple lines.", tf.description); |
|
t.t(tf.parameters.id.optional); |
|
t.is("Duplicate matched in signature and in line", tf.parameters.id.summary); |
|
t.is("String", tf.parameters.id.type); |
|
}, |
|
|
|
function test_returner(t){ |
|
|
|
// FIXME: the absence of a return comment populates only return_summary |
|
// when it's like: |
|
// --- |
|
// returns: Foo|Bar|Baz |
|
// You'd expect Foo|Bar|Baz to be return value, and this to be return_summary |
|
// --- |
|
|
|
var r = getmember("dojo.returner"); |
|
t.t(r); |
|
|
|
// FIXME: expected but not getting: |
|
// t.is("String|Integer", r.returns); |
|
// t.is("This should be description", r.return_summary); |
|
|
|
// FIXME: actually getting: |
|
t.is("String|Integer\nThis should be description", r.return_summary); |
|
t.f(r.returns); |
|
}, |
|
|
|
function test_multireturner(t){ |
|
var r = getmember("dojo.multiReturns"); |
|
t.t(r); |
|
t.is("String|Integer", r.returns, "found all return statement types in block"); |
|
t.is("Simple multireturn check", r.summary); |
|
}, |
|
|
|
function aliased_query(t){ |
|
var dq = getmember("dojo.query.stub"); |
|
t.t(dq, "$ -> dojo.query unwrapped from closure"); |
|
t.is("Integer", dq.returns); |
|
t.is("aliased to `dojo.query`", dq.summary, "FIX: requires undone <code>"); |
|
}, |
|
|
|
function kwarg_test(t){ |
|
var kw = getmember("util.docscripts.tests.simple.__kwArgs"); |
|
var args = kw.parameters; |
|
|
|
// FIXME: should this be actually mixed into something that has a type=__kwArgs? |
|
// eg: dojo.kwArgFunction.parameter.args object? |
|
var kwf = getmember("dojo.kwArgFunction"); |
|
var kwp = kwf.parameters.args; |
|
|
|
t.is("util.docscripts.tests.simple.__kwArgs", kwp.type); |
|
|
|
}, |
|
|
|
// function fetch_amd_style(t){ |
|
// docs = getdata("util/docscripts/tests/simple_amd.js"); |
|
// console.warn("amd-basic", docs); |
|
// }, |
|
// |
|
// function fetch_amd_declare(t){ |
|
// docs = getdata("util/docscripts/tests/declare_amd.js"); |
|
// console.warn("amg-declare", docs); |
|
// }, |
|
|
|
function functional(t){ |
|
// refs #13345 |
|
docs = getdata("util/docscripts/tests/functional.js"); |
|
var hasit = getmember("util.docscripts.tests.FunctionalThinger"); |
|
t.t(hasit, "object exists in parsed output, meaning parsing happened"); |
|
}, |
|
|
|
function raw_declare_init(t){ |
|
docs = getdata("util/docscripts/tests/extend_declare.js"); |
|
t.t(true); |
|
}, |
|
|
|
function raw_declare(t){ |
|
var barbaz = getmember("dojo.BarBaz"); |
|
t.t(barbaz, "raw declare() call defined a named class"); |
|
}, |
|
|
|
function lang_extend(t){ |
|
var someprop = getmember("dojo.BarBaz.someProp"); |
|
t.t(someprop, "lang.extend worked"); |
|
t.is("String", someprop.type, "lang.extend unwrapped innards"); |
|
}, |
|
|
|
// FIXME; dojo.mixin(a.b.prototype, { ... }) parses, but shows up differently in the obj |
|
// ... differently than dojo.extend(a.b, { ... }) ... the former is attached to "a.b", the |
|
// latter attached to "a.b.prototype". no sure how this pans out for generate.php |
|
// |
|
// function lang_mixin(t){ |
|
// var someprop = getmember("dojo.BarBaz.moreProps"); |
|
// console.log(docs, someprop); |
|
// t.t(someprop, "lang._mixin worked"); |
|
// t.is("String", someprop.type, "lang._mixin unwrapped innards"); |
|
// }, |
|
// |
|
|
|
function winning(t){ |
|
var prop = getmember("dojo.BarBaz.winning"); |
|
console.warn(prop); |
|
t.t(prop, "aliased extend() call resolves properly"); |
|
t.is("Boolean", prop.type); |
|
t.is("Always true.", prop.summary, "are we? rad.") |
|
} |
|
|
|
]); |
|
|
|
})();
|
|
|