public
Created

  • Download Gist
gistfile1.txt
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138
07:33:44< Mithaldu> is it just me or does Test::Class fight subclassing nail and tooth?
07:33:58< rjbs> just you, I think
07:34:05< Mithaldu> alright
07:34:20< Mithaldu> how do i subclass _run_method? :/
07:34:32< rjbs> presumably you don't.
07:34:45< rjbs> the _ means it's private, and subclassing that stuff is usually a bad idea, because it isn't meant for anybody else to think about
07:34:54< rjbs> probably the interface needs to be clarified, documented.
07:35:04< Mithaldu> i'm trying to make it wrap any "Tests"-marked sub in subtests from Test::More
07:35:43< Mithaldu> and that's basically the only point where i can see that happening :/
07:36:29< Mithaldu> hmm, or i just rewrite the namespace of my test class
07:36:32< Mithaldu> nasty, but welp
07:38:47< kentnl> Mithaldu: even the author of T/C just calls "subtest" in a method =(
07:39:16< Mithaldu> woo :/
07:39:38< kentnl> and attribute decorated methods suck imo
07:40:10< Mithaldu> i don't have an opinion there really
07:40:15< Mithaldu> i just need to get a job done
 
07:58:15< Mithaldu> ok, subtests working
07:58:18< stephan48> and tbh i never finished the campaigns without cheats ;)
07:58:21< Mithaldu> let's see how we can sprice this up
07:58:24< Mithaldu> *spruce
08:06:47< Mithaldu> http://gist.github.com/527670
08:06:48< dipsy> [ gist: 527670 - GitHub ]
08:06:52< Mithaldu> thoughts?
08:21:10< kentnl> mmmm. Tits.
08:21:18< kentnl> Oh, you mean thoughts on your *link*
08:21:28< Mithaldu> :p
08:21:51 * rafl sees attrs and runs
08:22:49< kentnl> My head hurts =(
08:22:57< kentnl> How does one use this?
08:23:15< Mithaldu> use parent 'Test::Class::Subtest';
08:23:20< kentnl> things are easier to understand when coupled with API usage examples. =)
08:23:22< Mithaldu> sub overrides_basic : Subtest {
08:23:25< Mithaldu> alternatively
08:23:30< Mithaldu> sub overrides_no_profile : Subtest(configuration overrides work if all no profile is given) {
08:24:07< Mithaldu> i guess i'm just too used to munging the symbol table at this point
08:24:41< kentnl> how does it know what its a subtest *of* ?
08:24:43< Mithaldu> either ways, the api is really simple, it works just like
08:24:59< Mithaldu> sub subname : Tests {
08:25:03< Mithaldu> in Test::Class
08:25:14< Mithaldu> only it wraps the sub in Test::More's subtest
08:25:23< Mithaldu> it's not a subtest of something :)
08:25:26< Mithaldu> sec
08:25:41< Mithaldu> http://search.cpan.org/~mschwern/Test-Simple-0.96/lib/Test/More.pm
08:25:42< dipsy> [ Test::More - search.cpan.org ]
08:25:44< Mithaldu> ctrl+f subtest there
08:27:29< Mithaldu> ugh, i dumb
08:27:44< kentnl> the thing is, test-more's 'subtest' *is* a subtest of something
08:28:05 * kentnl wrote something that used subtest so I get it =)
08:28:13< Mithaldu> i read it more as grouping something else
08:28:21< kentnl> you can do subtest inside a subtest, and it indents further
08:28:21< Mithaldu> either ways, i don't understand your question then
08:28:39< kentnl> and each subtest is a single test to its parent context
08:29:02< Mithaldu> uh
08:29:07< Mithaldu> let me put it like this:
08:29:16< Mithaldu> http://stackoverflow.com/questions/3496544/is-there-a-way-to-have-testclasss-tests-subs-always-act-like-testmores-su
08:29:19< dipsy> urgh. long url. Try http://tinyurl.com/27v3fxx
08:29:19< dipsy> [ Is there a way to have Test::Class's "Tests" subs always act like Test::More's subtests? - Stack Overflow ]
08:30:18< kentnl> ok 1 - overrides_basic # one test in the parent context =)
08:30:35< Mithaldu> yeah
08:30:48< Mithaldu> with all tests inside the sub being subtests of it
08:31:21< kentnl> if you're just wanting to say "this one test method contains multiple tests" then something other than "subtests" should be used imo, becuase its confusing
08:31:52< Mithaldu> um
08:32:05< kentnl> because I had thought you'd be doing lots of sub foo : Subtest { ok( ) } and expecting them to be magically grouped under a parent somehow
08:32:06< Mithaldu> my api is exactly like the api for subtest in Test::More
08:32:19< Mithaldu> no
08:32:26< Mithaldu> i just want it to work exactly the same
08:32:37< Mithaldu> just by ATTR instead of directly
08:33:56< Mithaldu> i'm sorry, i'm really trying to understand, but i don't get your line of thinking
08:36:47< kentnl> to my line of thought, sub foo :Test { } should contain only 1 test.
08:37:07< Mithaldu> that is still as it is
08:37:07< kentnl> and likewise, sub foo :SubTest { } one test also
08:37:23< Mithaldu> why?
08:37:24< dipsy> because
08:37:36< kentnl> becuase thats how its parent acts =)
08:37:38< Mithaldu> Test::More::subtest contains multiple tests too?
08:37:42< kentnl> 1 test vs 1 subtest
08:37:49< kentnl> they're the same concept
08:37:56< kentnl> 1 test can have many subtests
08:38:07< kentnl> 1 subtest can have many subtests
08:38:12< Mithaldu> so you're saying it should be subtests?
08:38:33< kentnl> possibly. :TestGroup would probably be more obvious.
08:39:01< kentnl> Its explicit in what it does.
08:39:13< Mithaldu> hmmm
08:39:21< Mithaldu> you got a point there
08:39:32< Mithaldu> oh well, why not
08:40:20< kentnl> its just "subtests" suggests "we are under something" and that "something" is not obvious =)
08:40:43< Mithaldu> you're saying the original subtest api is badly named, right? :)
08:41:26< kentnl> in the context of Test::More its fine, because one file contains many tests, and thus a "subtest" makes sence in that context
08:41:34< Mithaldu> um
08:41:38< Mithaldu> test class works the same
08:41:47< Mithaldu> you have many tests in each class
08:41:54< kentnl> yes, but its different =)
08:42:03< Mithaldu> aaaaaaaaaaaaaaaaaaaaaaaaa
08:42:10< kentnl> the scope of each sub is your 'scope' now
08:42:22< kentnl> previously your scope was the whole .t file
08:42:32< Mithaldu> well
08:42:38< Mithaldu> there's the problem
08:42:55< Mithaldu> if you look at the output of a Test::Class test, they aren't scoped to subs
08:43:01< Mithaldu> they're scoped to the class itself
08:43:31< Mithaldu> it doesn't even reset the number counts between subs
08:44:05< kentnl> :(
08:44:29< Mithaldu> that's why i was all :< and went and wrote a terrible module that uses symbol table munging :p
08:44:44< Mithaldu> ps: want to see real horror?
08:45:01< kentnl> not sure >_>
08:47:01< Mithaldu> uploading it, just because i did not yet
08:49:24< Mithaldu> http://gist.github.com/527740
08:49:25< dipsy> [ gist: 527740 - GitHub ]
08:49:33< Mithaldu> the very short of it
08:50:45< Mithaldu> this lets you load ExporterModule in such a way that it copies all subs from $var::ExporterModule
08:51:03< Mithaldu> and $var can be changed at runtime and ExporterModule reloaded at runtime to get different subs
08:51:21< kentnl> O_o.
08:51:28< Mithaldu> i wrote this because someone wrote very very very dumb code and my solution was marginally less dumb
08:51:35< Mithaldu> (it did not break the perl debugger)
08:52:05 * kentnl wrote some insane Test::StructuredObject thing which pretty much makes your code into a lazy-executed AST. But its very nasty and I need a better way of doing it that doesn't kill me with parentheses
08:52:18< Mithaldu> what's an AST?
08:52:24< kentnl> AbstractSyntaxTree
08:52:26< Mithaldu> aside from a wooden stick
08:53:27 * kentnl has the criteria of "one line of code per test sub" which results in the cool property I can parse and reformat the test-code into a form thats serial in the event I have to run it on a Test::More without the subtests feature
08:53:31< Mithaldu> that structured thing looks interesting
08:54:03< kentnl> it does require you to do some weird things though.
08:54:47< kentnl> like for instance, because you can only have one loc per sub, you have to predeclare all the variables in advance and use them like registers >_>]
08:54:50< Mithaldu> i *think* i get the basic idea
08:55:01< Mithaldu> that sounds terrible :o
08:55:30< kentnl> it is interesting in what it makes you get out though. Sort of like using a template language encourages you to seperate concerns
08:55:40< kentnl> but I'm not entirely sure my approch is good yet =P
08:55:57< Mithaldu> i couldn't tell
08:56:03< Mithaldu> i'm not grokking it enough :)
08:56:10< kentnl> Yeah, Its poorly documented.
08:57:05< kentnl> It also has the advantage of doing it that way is you get a guaranteed expected test count.
08:57:26< kentnl> ie: without "Done testing" , and without counting them all yourself.
08:57:36< Mithaldu> not sure i care about that much
08:57:40< Mithaldu> i like done testing :)
08:57:59< Mithaldu> oh wait
08:58:03< Mithaldu> Test::StructuredObject IS from you
08:58:09< Mithaldu> i did not make that connection :D
08:58:10< kentnl> done testing is only nasty if you accidentally somehow run less tests than you expected youd run, you'll never see =)
08:58:13< kentnl> =)

Please sign in to comment on this gist.

Something went wrong with that request. Please try again.