source: wiki-toolkit/trunk/t/150_plugins.t @ 322

Last change on this file since 322 was 322, checked in by nick, 14 years ago

Correctly calculate (and skip) the number of tests when test::mockobject isn't installed

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 10.4 KB
Line 
1use strict;
2use Wiki::Toolkit::TestLib;
3use Test::More;
4
5if ( scalar @Wiki::Toolkit::TestLib::wiki_info == 0 ) {
6    plan skip_all => "no backends configured";
7} else {
8    plan tests => ( 28 * scalar @Wiki::Toolkit::TestLib::wiki_info );
9}
10
11my $iterator = Wiki::Toolkit::TestLib->new_wiki_maker;
12
13while ( my $wiki = $iterator->new_wiki ) {
14    SKIP: {
15        eval { require Test::MockObject; };
16        skip "Test::MockObject not installed", 28 if $@;
17
18        my $null_plugin = Test::MockObject->new;
19
20        my $plugin = Test::MockObject->new;
21        $plugin->mock( "on_register",
22                       sub {
23                           my $self = shift;
24                           $self->{__registered} = 1;
25                           $self->{__seen_nodes} = [ ];
26                           $self->{__deleted_nodes} = [ ];
27                           $self->{__moderated_nodes} = [ ];
28                           $self->{__pre_moderated_nodes} = [ ];
29                           $self->{__pre_write_nodes} = [ ];
30                           $self->{__pre_retrieve_nodes} = [ ];
31                           }
32                      );
33        eval { $wiki->register_plugin; };
34        ok( $@, "->register_plugin dies if no plugin supplied" );
35        eval { $wiki->register_plugin( plugin => $null_plugin ); };
36        is( $@, "",
37     "->register_plugin doesn't die if plugin which can't on_register supplied"
38          );
39        eval { $wiki->register_plugin( plugin => $plugin ); };
40        is( $@, "",
41       "->register_plugin doesn't die if plugin which can on_register supplied"
42          );
43        ok( $plugin->{__registered}, "->on_register method called" );
44
45        my @registered = $wiki->get_registered_plugins;
46        is( scalar @registered, 2,
47            "->get_registered_plugins returns right number" );
48        ok( ref $registered[0], "...and they're objects" );
49
50        my $regref = $wiki->get_registered_plugins;
51        is( ref $regref, "ARRAY", "...returns arrayref in scalar context" );
52
53# ===========================================================================
54
55                # Test the post_write (adding/updating a node) plugin call
56                # (Writes a node, and ensures the post_write plugin was called
57                #  with the appropriate options)
58        $plugin->mock( "post_write",
59                                                sub {
60                                                        my ($self, %args) = @_;
61                                                        push @{ $self->{__seen_nodes} },
62                                                        { node     => $args{node},
63                                                          node_id  => $args{node_id},
64                                                          version  => $args{version},
65                                                          content  => $args{content},
66                                                          metadata => $args{metadata}
67                                                        };
68                                                }
69        );
70
71        $wiki->write_node( "Test Node", "foo", undef, {bar => "baz"} )
72            or die "Can't write node";
73        ok( $plugin->called("post_write"), "->post_write method called" );
74
75        my @seen = @{ $plugin->{__seen_nodes} };
76        is_deeply( $seen[0], { node => "Test Node",
77                               node_id => 1,
78                               version => 1,
79                               content => "foo",
80                               metadata => { bar => "baz" } },
81                   "...with the right arguments" );
82
83# ===========================================================================
84
85                # Test the post_delete (deletion) plugin call
86                # (Deletes nodes with and without versions, and ensured that
87                #  post_delete was called with the appropriate options)
88        $plugin->mock( "post_delete",
89                                                sub {
90                                                        my ($self, %args) = @_;
91                                                        push @{ $self->{__deleted_nodes} },
92                                                        { node     => $args{node},
93                                                          node_id  => $args{node_id},
94                                                          version  => $args{version},
95                                                        };
96                                                }
97        );
98
99
100                # Delete with a version
101        $wiki->delete_node( name=>"Test Node", version=>1 )
102            or die "Can't delete node";
103        ok( $plugin->called("post_delete"), "->post_delete method called" );
104
105        my @deleted = @{ $plugin->{__deleted_nodes} };
106        is_deeply( $deleted[0], { node => "Test Node",
107                               node_id => 1,
108                               version => undef },
109                   "...with the right arguments" );
110        $plugin->{__deleted_nodes} = [];
111
112
113                # Now add a two new versions
114                my %node = $wiki->retrieve_node("Test Node 2");
115        $wiki->write_node( "Test Node 2", "bar", $node{checksum} )
116            or die "Can't write second version node";
117                %node = $wiki->retrieve_node("Test Node 2");
118        $wiki->write_node( "Test Node 2", "foofoo", $node{checksum} )
119            or die "Can't write second version node";
120
121                # Delete newest with a version
122        $wiki->delete_node( name=>"Test Node 2", version=>2 )
123            or die "Can't delete node";
124        ok( $plugin->called("post_delete"), "->post_delete method called" );
125
126        @deleted = @{ $plugin->{__deleted_nodes} };
127        is_deeply( $deleted[0], { node => "Test Node 2",
128                               node_id => 2,
129                               version => 2 },
130                   "...with the right arguments" );
131
132                # And delete without a version
133        $wiki->delete_node( name=>"Test Node 2" )
134            or die "Can't delete node";
135        ok( $plugin->called("post_delete"), "->post_delete method called" );
136
137        @deleted = @{ $plugin->{__deleted_nodes} };
138        is_deeply( $deleted[1], { node => "Test Node 2",
139                               node_id => 2,
140                               version => undef },
141                   "...with the right arguments" );
142
143# ===========================================================================
144
145                # Test the moderation plugins
146                # (Adds nodes that require moderation and moderates them,
147                #  ensuring pre_moderate and post_moderate are called with
148                #  the appropriate options)
149        $plugin->mock( "pre_moderate",
150                                                sub {
151                                                        my ($self, %args) = @_;
152                                                        push @{ $self->{__pre_moderated_nodes} },
153                                                        { node     => ${$args{node}},
154                                                          version  => ${$args{version}}
155                                                        };
156                                                }
157        );
158        $plugin->mock( "post_moderate",
159                                                sub {
160                                                        my ($self, %args) = @_;
161                                                        push @{ $self->{__moderated_nodes} },
162                                                        { node     => $args{node},
163                                                          node_id  => $args{node_id},
164                                                          version  => $args{version},
165                                                        };
166                                                }
167        );
168
169                # Add
170        $wiki->write_node( "Test Node 3", "bar" )
171            or die "Can't write first version node";
172
173                # Moderate
174        $wiki->moderate_node( name=>"Test Node 3", version=>1 )
175            or die "Can't moderate node";
176        ok( $plugin->called("pre_moderate"), "->pre_moderate method called" );
177        ok( $plugin->called("post_moderate"), "->post_moderate method called" );
178
179        my @pre_moderated = @{ $plugin->{__pre_moderated_nodes} };
180        is_deeply( $pre_moderated[0], { node => "Test Node 3",
181                               version => 1 },
182                   "...with the right arguments" );
183
184        my @moderated = @{ $plugin->{__moderated_nodes} };
185        is_deeply( $moderated[0], { node => "Test Node 3",
186                               node_id => 3,
187                               version => 1 },
188                   "...with the right arguments" );
189
190# ===========================================================================
191
192                # Test using pre_write to alter things
193                # (Adds a pre_write plugin that alters the settings, writes, and
194                #  ensure that pre_write gets the unaltered stuff, and post_write
195                #  the altered)
196        $plugin->mock( "pre_write",
197                                                sub {
198                                                        my ($self, %args) = @_;
199
200                                                        # Tweak
201                                                        ${$args{node}} = "CHANGED_NAME";
202                                                        ${$args{content}} = "Changed: ".${$args{content}};
203                                                        ${$args{metadata}}->{foo} = "bar";
204                                                       
205                                                        # Save
206                                                        push @{ $self->{__pre_write_nodes} },
207                                                        { node     => ${$args{node}},
208                                                          content  => ${$args{content}},
209                                                          metadata  => ${$args{metadata}},
210                                                        };
211                                                }
212        );
213
214        $wiki->write_node( "Test Node", "foo", undef, {bar => "baz"} )
215            or die "Can't write node with pre_write";
216        ok( $plugin->called("pre_write"), "->pre_write method called" );
217
218        my @changed = @{ $plugin->{__pre_write_nodes} };
219        is_deeply( $changed[0], { node => "CHANGED_NAME",
220                               content => "Changed: foo",
221                               metadata => { bar=>"baz", foo=>"bar" } },
222                   "...with the right (changed) arguments" );
223
224        @seen = @{ $plugin->{__seen_nodes} };
225        is_deeply( $seen[4], { node => "CHANGED_NAME",
226                               node_id => 4,
227                               version => 1,
228                               content => "Changed: foo",
229                               metadata => { bar=>"baz", foo=>"bar" } },
230                   "...with the right (changed) arguments" );
231
232# ===========================================================================
233
234                # Test using pre_retrieve to alter things
235                # (Adds a pre_retrieve plugin that alters the settings, and
236                #  ensure that pre_retrieve gets the unaltered stuff, and the read
237                #  gets the altered)
238
239                # Do a normal fetch
240                my %nv = $wiki->retrieve_node(name=>"CHANGED_NAME",version=>1);
241
242                # Register the plugin
243        $plugin->mock( "pre_retrieve",
244                                                sub {
245                                                        my ($self, %args) = @_;
246
247                                                        my $orig_node = ${$args{node}};
248                                                        my $orig_ver = ${$args{version}};
249
250                                                        # Tweak
251                                                        ${$args{node}} = "CHANGED_NAME";
252                                                        ${$args{version}} = 1;
253                                                       
254                                                        # Save
255                                                        push @{ $self->{__pre_retrieve_nodes} },
256                                                        { node      => ${$args{node}},
257                                                          version   => ${$args{version}},
258                                                          orig_node => $orig_node,
259                                                          orig_ver  => $orig_ver,
260                                                        };
261                                                }
262        );
263
264                # Do a fetch with no version
265                my %dnv = $wiki->retrieve_node("foo");
266        my @ret = @{ $plugin->{__pre_retrieve_nodes} };
267        is_deeply( $ret[0], { node => "CHANGED_NAME",
268                               version => 1,
269                               orig_node => "foo",
270                               orig_ver => undef },
271                   "...with the right (changed) arguments" );
272
273                is($dnv{'content'}, "Changed: foo", "Retrieve was altered" );
274        is_deeply( \%dnv, \%nv, "Retrieve was altered" );
275
276                # And with too high a version
277                my %dv = $wiki->retrieve_node(name=>"foo", version=>22);
278        @ret = @{ $plugin->{__pre_retrieve_nodes} };
279        is_deeply( $ret[1], { node => "CHANGED_NAME",
280                               version => 1,
281                               orig_node => "foo",
282                               orig_ver => 22 },
283                   "...with the right (changed) arguments" );
284
285                is($dv{'content'}, "Changed: foo", "Retrieve was altered" );
286        is_deeply( \%dv, \%nv, "Retrieve was altered" );
287    }
288}
Note: See TracBrowser for help on using the repository browser.