Merge branch 'master' into cvs
[ikiwiki.git] / t / cvs.t
1 #!/usr/bin/perl
2 use warnings;
3 use strict;
4 use Test::More; my $total_tests = 9;
5 use IkiWiki;
6
7 my $default_test_methods = '^test_*';
8 my @required_programs = qw(
9         cvs
10         cvsps
11 );
12 my @required_modules = qw(
13         File::chdir
14         File::MimeInfo
15         Date::Parse
16         File::Temp
17         File::ReadBackwards
18 );
19 my $dir = "/tmp/ikiwiki-test-cvs.$$";
20
21 # TESTS FOR GENERAL META-BEHAVIOR
22
23 sub test_web_add_and_commit {
24         my $message = "Add a page via VCS API";
25         writefile('test1.mdwn', $config{srcdir}, readfile("t/test1.mdwn"));
26         IkiWiki::rcs_add("test1.mdwn");
27         IkiWiki::rcs_commit(
28                 file => "test1.mdwn",
29                 message => $message,
30                 token => "moo",
31         );
32
33         my @changes = IkiWiki::rcs_recentchanges(3);
34         is(
35                 $#changes,
36                 0,
37                 q{1 total commit},
38         );
39         is(
40                 $changes[0]{message}[0]{"line"},
41                 $message,
42                 q{first line of most recent commit message matches},
43         );
44         is(
45                 $changes[0]{pages}[0]{"page"},
46                 "test1",
47                 q{first pagename from most recent commit matches},
48         );
49
50         # prevent web edits from attempting to create .../CVS/foo.mdwn
51         # on case-insensitive filesystems, also prevent .../cvs/foo.mdwn
52         # unless your "CVS" is something else and we've made it configurable
53         # how much of the web-edit workflow are we actually testing?
54         # because we want to test comments:
55         # - when the first comment for page.mdwn is added, and page/ is
56         #   created to hold the comment, page/ isn't added to CVS control,
57         #   so the comment isn't either
58         # - side effect for moderated comments: after approval they
59         #   show up normally AND are still pending, too
60         # - comments.pm treats rcs_commit_staged() as returning conflicts?
61 }
62
63 sub test_manual_add_and_commit {
64         my $message = "Add a page via CVS directly";
65         writefile('test2.mdwn', $config{srcdir}, readfile("t/test2.mdwn"));
66         system "cd $config{srcdir}"
67                 . " && cvs add test2.mdwn >/dev/null 2>&1";
68         system "cd $config{srcdir}"
69                 . " && cvs commit -m \"$message\" test2.mdwn >/dev/null";
70
71         my @changes = IkiWiki::rcs_recentchanges(3);
72         is(
73                 $#changes,
74                 0,
75                 q{1 total commit},
76         );
77         is(
78                 $changes[0]{message}[0]{"line"},
79                 $message,
80                 q{first line of most recent commit message matches},
81         );
82         is(
83                 $changes[0]{pages}[0]{"page"},
84                 "test2",
85                 q{first pagename from most recent commit matches},
86         );
87
88         # CVS commits run ikiwiki once for every committed file (!)
89         # - commit_prep alone should fix this
90         # CVS multi-dir commits show only the first dir in recentchanges
91         # - commit_prep might also fix this?
92         # CVS post-commit hook is amped off to avoid locking against itself
93         # - commit_prep probably doesn't fix this... but maybe?
94 }
95
96 sub test_chdir_magic {
97         # cvs.pm operations are always occurring inside $config{srcdir}
98         # other ikiwiki operations are occurring wherever, and are unaffected
99         # when are we bothering with "local $CWD" and when aren't we?
100 }
101
102 sub test_cvs_info {
103         # inspect "Repository revision" (used in code)
104         # inspect "Sticky Options" (used in tests to verify existence of "-kb")
105 }
106
107 sub test_cvs_run_cvs {
108         # extract the stdout-redirect thing
109         # - prove that it silences stdout
110         # - prove that stderr comes through just fine
111         # prove that when cvs exits nonzero (fail), function exits false
112         # prove that when cvs exits zero (success), function exits true
113         # always pass -f, just in case
114         # steal from git.pm: safe_git(), run_or_{die,cry,non}
115         # - open() instead of system()
116         # always call cvs_run_cvs(), don't ever run 'cvs' directly
117 }
118
119 sub test_cvs_run_cvsps {
120         # parameterize command like run_cvs()
121         # expose config vars for e.g. "--cvs-direct -z 30"
122         # always pass -x (unless proven otherwise)
123         # always pass -b HEAD (configurable like gitmaster_branch?)
124 }
125
126 sub test_cvs_parse_cvsps {
127         # extract method from rcs_recentchanges
128         # document expected changeset format
129         # document expected changeset delimiter
130         # try: cvsps -q -x -p && ls | sort -rn | head -100
131         # - benchmark against current impl (that uses File::ReadBackwards)
132 }
133
134 sub test_cvs_parse_log_accum {
135         # add new, preferred method for rcs_recentchanges to use
136         # teach log_accum to record commits (into transient?)
137         # script cvsps to bootstrap (or replace?) commit history
138         # teach ikiwiki-makerepo to set up log_accum and commit_prep
139         # why are NetBSD commit mails unreliable?
140         # - is it working for CVS commits and failing for web commits?
141 }
142
143 sub test_cvs_is_controlling {
144         # with no args:
145         # - if srcdir is in CVS, return true
146         # - else, return false
147         # with a dir arg:
148         # - if dir is in CVS, return true
149         # - else, return false
150         # with a file arg:
151         # - is there anything that wants the answer? if so, answer
152         # - else, die
153 }
154
155
156 # TESTS FOR GENERAL PLUGIN API CALLS
157
158 sub test_checkconfig {
159         # undef cvspath, expect "ikiwiki"
160         # define cvspath normally, get it back
161         # define cvspath in a subdir, get it back?
162         # define cvspath with extra slashes, get sanitized version back
163         # - yoink test_extra_path_slashes
164         # undef cvs_wrapper, expect $config{wrappers} same size as before
165
166         my $initial_cvspath = $config{cvspath};
167         $config{cvspath} = "/ikiwiki//";
168         IkiWiki::checkconfig();
169         is(
170                 $config{cvspath},
171                 $initial_cvspath,
172                 q{rcs_recentchanges assumes checkconfig has sanitized cvspath},
173         );
174 }
175
176 sub test_getsetup {
177         # anything worth testing?
178 }
179
180 sub test_genwrapper {
181         # testable directly? affects rcs_add, but are we exercising this?
182 }
183
184
185 # TESTS FOR VCS PLUGIN API CALLS
186
187 sub test_rcs_update {
188         # can it assume we're under CVS control? or must it check?
189         # anything else worth testing?
190 }
191
192 sub test_rcs_prepedit {
193         # can it assume we're under CVS control? or must it check?
194         # for existing file, returns latest revision in repo
195         # - what's this used for? should it return latest revision in checkout?
196         # for new file, returns empty string
197 }
198
199 sub test_rcs_commit {
200         # can it assume we're under CVS control? or must it check?
201         # if someone else changed the page since rcs_prepedit was called:
202         # - try to merge into our working copy
203         # - if merge succeeds, proceed to commit
204         # - else, return page content with the conflict markers in it
205         # commit:
206         # - if success, return undef
207         # - else, revert + return content with the conflict markers in it
208         # git.pm receives "session" param -- useful here?
209         # web commits start with "web commit {by,from} "
210         # seeing File::chdir errors on commit?
211 }
212
213 sub test_rcs_commit_staged {
214         # if commit succeeds, return undef
215         # else, warn and return error message (really? or just non-undef?)
216 }
217
218 sub test_rcs_add {
219         my $dir1 = "test3";
220         my $dir2 = "test4/test5";
221         ok(
222                 mkdir($config{srcdir} . "/$dir1"),
223                 qq{can make $dir1},
224         );
225         IkiWiki::rcs_add($dir1);
226         IkiWiki::rcs_commit(
227                 file => $dir1,
228                 message => "shouldn't happen",
229                 token => "oom",
230         );
231
232         # can it assume we're under CVS control? or must it check?
233         # add a top-level text file
234         # - rcs_commit it
235         # - inspect recentchanges: new change, no -kb
236         # add a top-level dir
237         # - test mustn't hang (does it hang if we comment out genwrapper?)
238         # - inspect recentchanges: no new change
239         # - rcs_commit it
240         # - reinspect recentchanges: still no new change
241         # add a text file in that dir
242         # - rcs_commit_staged
243         # - inspect recentchanges: new change, no -kb
244         # add a top-level dir + add a binary file in it
245         # - rcs_commit_staged
246         # - inspect recentchanges: new change, yes -kb
247         # add a top-level dir + subdir + add one text and one binary file in it
248         # - rcs_commit_staged
249         # - inspect recentchanges: one new change, two files, one -kb, one not
250
251         # extract method: filetype-guessing
252         # add a binary file, remove it, add a text file by same name, no -kb?
253         # add a text file, remove it, add a binary file by same name, -kb?
254 }
255
256 sub test_rcs_remove {
257         # can it assume we're under CVS control? or must it check?
258         # remove a top-level file
259         # - rcs_commit
260         # - inspect recentchanges: one new change, file removed
261         # remove two files (in different dirs)
262         # - rcs_commit_staged
263         # - inspect recentchanges: one new change, both files removed
264 }
265
266 sub test_rcs_rename {
267         # can it assume we're under CVS control? or must it check?
268         # rename a file in the same dir
269         # - rcs_commit_staged
270         # - inspect recentchanges: one new change, one file removed, one added
271         # rename a file into a different dir
272         # - rcs_commit_staged
273         # - inspect recentchanges: one new change, one file removed, one added
274         # rename a file into a not-yet-existing dir
275         # - rcs_commit_staged
276         # - inspect recentchanges: one new change, one file removed, one added
277         # is it safe to use "mv"? what if $dest is somehow outside the wiki?
278 }
279
280 sub test_rcs_recentchanges {
281         # can it assume we're under CVS control? or must it check?
282         # don't worry whether we're called with a number (we always are)
283         # other rcs tests already inspect much of the returned structure
284         # CVS commits say "cvs" and get the right committer
285         # web commits say "web" and get the right committer
286         # - and don't start with "web commit {by,from} "
287         # "nickname" -- can we ever meaningfully set this?
288
289         # prefer log_accum, then cvsps, else die
290         # run the high-level recentchanges tests 2x (once for each method)
291         # - including in other test subs that check recentchanges?
292 }
293
294 sub test_rcs_diff {
295         # can it assume we're under CVS control? or must it check?
296         # in list context, return all lines (with \n), up to $maxlines if set
297         # in scalar context, return the whole diff, up to $maxlines if set
298 }
299
300 sub test_rcs_getctime {
301         # can it assume we're under CVS control? or must it check?
302         # given a file, find its creation time, else return 0
303         # first implement in the obvious way
304         # then cache
305 }
306
307 sub test_rcs_getmtime {
308         # can it assume we're under CVS control? or must it check?
309         # given a file, find its modification time, else return 0
310         # first implement in the obvious way
311         # then cache
312 }
313
314 sub test_rcs_receive {
315         pass(q{rcs_receive doesn't make sense for CVS});
316 }
317
318 sub test_rcs_preprevert {
319         # can it assume we're under CVS control? or must it check?
320         # given a patchset number, return structure describing what'd happen:
321         # - see doc/plugins/write.mdwn:rcs_receive()
322         # don't forget about attachments
323 }
324
325 sub test_rcs_revert {
326         # can it assume we're under CVS control? or must it check?
327         # given a patchset number, stage the revert for rcs_commit_staged()
328         # if commit succeeds, return undef
329         # else, warn and return error message (really? or just non-undef?)
330 }
331
332 sub main {
333         my $test_methods = defined $ENV{TEST_METHOD} 
334                          ? $ENV{TEST_METHOD}
335                          : $default_test_methods;
336
337         _startup($test_methods eq $default_test_methods);
338         _runtests(_get_matching_test_subs($test_methods));
339         _shutdown($test_methods eq $default_test_methods);
340 }
341
342 main();
343
344
345 # INTERNAL SUPPORT ROUTINES
346
347 sub _plan_for_test_more {
348         my $can_plan = shift;
349
350         foreach my $program (@required_programs) {
351                 my $program_path = `which $program`;
352                 chomp $program_path;
353                 return plan(skip_all => "$program not available")
354                         unless -x $program_path;
355         }
356
357         foreach my $module (@required_modules) {
358                 eval qq{use $module};
359                 return plan(skip_all => "$module not available")
360                         if $@;
361         }
362
363         return plan(skip_all => "can't create $dir: $!")
364                 unless mkdir($dir);
365         return plan(skip_all => "can't remove $dir: $!")
366                 unless rmdir($dir);
367
368         return unless $can_plan;
369
370         return plan(tests => $total_tests);
371 }
372
373 # http://stackoverflow.com/questions/607282/whats-the-best-way-to-discover-all-subroutines-a-perl-module-has
374
375 use B qw/svref_2object/;
376
377 sub in_package {
378         my ($coderef, $package) = @_;
379         my $cv = svref_2object($coderef);
380         return if not $cv->isa('B::CV') or $cv->GV->isa('B::SPECIAL');
381         return $cv->GV->STASH->NAME eq $package;
382 }
383
384 sub list_module {
385         my $module = shift;
386         no strict 'refs';
387         return grep {
388                 defined &{"$module\::$_"} and in_package(\&{*$_}, $module)
389         } keys %{"$module\::"};
390 }
391
392
393 # support for xUnit-style testing, a la Test::Class
394
395 sub _startup {
396         my $can_plan = shift;
397         _plan_for_test_more($can_plan);
398         _generate_test_config();
399 }
400
401 sub _shutdown {
402         my $had_plan = shift;
403         done_testing() unless $had_plan;
404 }
405
406 sub _setup {
407         _generate_test_repo();
408 }
409
410 sub _teardown {
411         system "rm -rf $dir";
412 }
413
414 sub _runtests {
415         my @coderefs = (@_);
416         for (@coderefs) {
417                 _setup();
418                 $_->();
419                 _teardown();
420         }
421 }
422
423 sub _get_matching_test_subs {
424         my $re = shift;
425         no strict 'refs';
426         return map { \&{*$_} } grep { /$re/ } sort(list_module('main'));
427 }
428
429 sub _generate_test_config {
430         %config = IkiWiki::defaultconfig();
431         $config{rcs} = "cvs";
432         $config{srcdir} = "$dir/src";
433         $config{cvsrepo} = "$dir/repo";
434         $config{cvspath} = "ikiwiki";
435         IkiWiki::loadplugins();
436         IkiWiki::checkconfig();
437 }
438
439 sub _generate_test_repo {
440         die "can't create $dir: $!"
441                 unless mkdir($dir);
442
443         my $cvs = "cvs -d $config{cvsrepo}";
444         my $dn = ">/dev/null";
445         system "$cvs init $dn";
446         system "mkdir $dir/$config{cvspath} $dn";
447         system "cd $dir/$config{cvspath} && "
448                 . "$cvs import -m import $config{cvspath} VENDOR RELEASE $dn";
449         system "rm -rf $dir/$config{cvspath} $dn";
450         system "$cvs co -d $config{srcdir} $config{cvspath} $dn";
451 }