[Templates-cvs] cvs commit: TT3/t provider.t
cvs@template-toolkit.org
cvs@template-toolkit.org
Tue, 23 Mar 2004 13:24:51 +0000
cvs 04/03/23 13:24:51
Added: t provider.t
Log:
* added tests for Template::Provider base class
Revision Changes Path
1.1 TT3/t/provider.t
Index: provider.t
===================================================================
#============================================================= -*-perl-*-
#
# t/provider.t
#
# Test the Template::Provider.pm module.
#
# Written by Andy Wardley <abw@wardley.org>
#
# This is free software; you can redistribute it and/or modify it
# under the same terms as Perl itself.
#
# $Id: provider.t,v 1.1 2004/03/23 13:24:51 abw Exp $
#
#========================================================================
use strict;
use warnings;
use lib qw( ./lib ../lib );
use File::Spec;
use Template::Provider;
use Test::More tests => 63;
my $DEBUG =
$Template::Provider::DEBUG =
grep(/^--?d(ebug)?/, @ARGV);
#------------------------------------------------------------------------
# basic test of constructor
#------------------------------------------------------------------------
my $pkg = 'Template::Provider';
my $prov = $pkg->new( ) || die $pkg->error();
ok( $prov, 'created a default provider' );
my $id1 = $prov->id();
my $id2 = $prov->id();
is( $id1, $id2, 'ids match' );
#------------------------------------------------------------------------
# id option
#------------------------------------------------------------------------
$prov = $pkg->new({
id => 'foobar',
}) || die $pkg->error();
ok( $prov, 'created a foobar provider' );
is( $prov->id(), 'foobar', 'id is foobar' );
#------------------------------------------------------------------------
# path option
#------------------------------------------------------------------------
$prov = $pkg->new({
path => '/tmp',
}) || die $pkg->error();
ok( $prov, 'created a provider with path' );
is( $prov->path()->[0], '/tmp', 'path is /tmp' );
my $paths = $prov->paths() || die $prov->error();
is( ref $paths, 'ARRAY', 'got an array of paths' );
is( scalar @$paths, 1, 'one path in list' );
is( $paths->[0], '/tmp', 'only path is /tmp' );
# call path() method to update path
is( $prov->path('/foo')->[0], '/foo', 'set path to foo' );
is( scalar @{ $prov->path() }, 1, 'still one path' );
is( $prov->path()->[0], '/foo', 'path still set to foo' );
#------------------------------------------------------------------------
# path list
#------------------------------------------------------------------------
$prov = $pkg->new({
path => ['/wiz', '/waz'],
}) || die $pkg->error();
ok( $prov, 'created a wiz/waz provider' );
is( $prov->path()->[0], '/wiz', 'first path is /wiz' );
is( $prov->path()->[1], '/waz', 'second path is /waz' );
$paths = $prov->paths() || die $prov->error();
is( $paths->[0], '/wiz', 'paths returned /wiz' );
is( $paths->[1], '/waz', 'paths returned /waz' );
#------------------------------------------------------------------------
# path subroutine
#------------------------------------------------------------------------
$prov = $pkg->new({
path => sub { return ['/foo', '/bar'] },
}) || die $pkg->error();
ok( $prov, 'created a provider with sub path' );
is( ref $prov->path()->[0], 'CODE', 'code ref' );
$paths = $prov->paths() || die $prov->error();
is( $paths->[0], '/foo', 'first sub path is /foo' );
is( $paths->[1], '/bar', 'second sub path is /bar' );
ok( $prov->path( sub { die "you bad provider!\n" } ), 'set bad path' );
ok( ! defined $prov->paths(), 'no paths no more' );
is( $prov->error(), 'you bad provider!', 'bad provider!' );
#------------------------------------------------------------------------
# path object
#------------------------------------------------------------------------
package Paths;
use base qw( Template::Base );
sub init {
my ($self, $config) = @_;
$self->{ path } = $config->{ path };
$self->{ sick } = $config->{ sick };
$self->{ barf } = $config->{ barf };
return $self;
}
sub paths {
my $self = shift;
die $self->{ sick } if $self->{ sick };
return $self->error($self->{ barf }) if $self->{ barf };
return $self->{ path } || $self->decline('no paths');
}
package main;
$prov = $pkg->new({
path => Paths->new( path => ['/foo', '/bar'] ),
}) || die $pkg->error();
ok( $prov, 'created a provider with path object' );
$paths = $prov->paths();
die ("no paths: ", $prov->error()) unless defined $paths;
is( $paths->[0], '/foo', 'first obj path is /foo' );
is( $paths->[1], '/bar', 'second obj path is /bar' );
# object throws an error via die()
$prov = $pkg->new({
path => Paths->new( sick => "big mistake\n" ),
}) || die $pkg->error();
ok( ! defined $prov->paths(), 'no obj paths' );
is( $prov->error(), 'big mistake', 'big mistake' );
# object reports an error with undef and error() method
$prov = $pkg->new({
path => Paths->new( barf => "chew on this" ),
}) || die $pkg->error();
$paths = $prov->paths();
ok( ! defined $prov->paths(), 'still no obj paths' );
is( $prov->error(), 'chew on this', 'chew on this' );
#------------------------------------------------------------------------
# nested paths
#------------------------------------------------------------------------
$prov = $pkg->new({
path => [ '/foo',
sub { ['/bar', sub { '/baz' } ] },
Paths->new( path => ['/wiz', Paths->new( path => '/waz' ) ] ) ],
}) || die $pkg->error();
$paths = $prov->paths() || die $prov->error();
$paths = join(':', @$paths);
is( $paths, '/foo:/bar:/baz:/wiz:/waz', 'all paths correct' );
#------------------------------------------------------------------------
# max paths limit
#------------------------------------------------------------------------
$prov = $pkg->new({
path => [ 0..20,
sub { [21..40] },
],
}) || die $pkg->error();
$paths = $prov->paths();
ok( ! defined $paths, 'no paths returned' );
is( $prov->error(), 'exceeded path limit (32)', 'exceeded path limit 32' );
$prov = $pkg->new({
path => [ 0..10 ],
max_paths => 5,
}) || die $pkg->error();
$paths = $prov->paths();
ok( ! defined $paths, 'still no paths returned' );
is( $prov->error(), 'exceeded path limit (5)', 'exceeded path limit 5' );
#------------------------------------------------------------------------
# test dynamic paths
#------------------------------------------------------------------------
my @data = ( [ qw( foo bar ) ], [ qw( wiz waz ) ] );
sub some_data {
return shift @data;
}
$prov = $pkg->new({
path => \&some_data,
}) || die $pkg->error();
ok( $prov, 'created dynamic provider' );
# get foo/bar first time
$paths = $prov->paths() || die $prov->error();
is( join(':', @$paths), 'foo:bar', 'got foo bar paths' );
# get wiz/waz second time
$paths = $prov->paths() || die $prov->error();
is( join(':', @$paths), 'wiz:waz', 'got wiz waz paths' );
#------------------------------------------------------------------------
# test static paths
#------------------------------------------------------------------------
@data = ( [ qw( ping pong ) ], [ qw( ding dong ) ] );
$prov = $pkg->new({
path => \&some_data,
static => 1,
}) || die $pkg->error();
ok( $prov, 'created static provider' );
# get ping/pong first time
$paths = $prov->paths() || die $prov->error();
is( join(':', @$paths), 'ping:pong', 'got ping pong paths' );
# get ping/pong second time
$paths = $prov->paths() || die $prov->error();
is( join(':', @$paths), 'ping:pong', 'got ping:pong again' );
$prov->path(\&some_data) || die $prov->error();
# get ding/dong second time
$paths = $prov->paths() || die $prov->error();
is( join(':', @$paths), 'ding:dong', 'got ding:dong' );
#------------------------------------------------------------------------
# test path options
#------------------------------------------------------------------------
$prov = $pkg->new({
path => [
foo => { a => 10, b => 20 },
bar => { a => 30, b => 40 },
],
}) || die $pkg->error();
ok( $prov, 'created provided with path options' );
$paths = $prov->paths() || die $prov->error();
my $pair = $paths->[0];
my ($path, $opts) = @$pair;
is( $path, 'foo', 'first path is foo' );
is( $opts->{ a }, 10, 'a is 10' );
is( $opts->{ b }, 20, 'b is 20' );
$pair = $paths->[1];
($path, $opts) = @$pair;
is( $path, 'bar', 'second path is bar' );
is( $opts->{ a }, 30, 'a is 30' );
is( $opts->{ b }, 40, 'b is 40' );
#------------------------------------------------------------------------
# test join_path() method
#------------------------------------------------------------------------
is( $prov->join_path('/foo', '/bar'), '/foo/bar', '/foo/bar path 1' );
is( $prov->join_path('/foo/', '/bar'), '/foo/bar', '/foo/bar path 2' );
is( $prov->join_path('/foo', 'bar'), '/foo/bar', '/foo/bar path 3' );
#------------------------------------------------------------------------
# test fetch() and fetch_path() methods in base class
#------------------------------------------------------------------------
$prov = $pkg->new({
path => ['/foo', '/bar'],
templates => {
'/foo/wiz' => 'Hello World',
'/bar/waz' => 'Goodbye World',
},
}) || die $pkg->error();
my $src = $prov->fetch('wiz') || die $prov->error();
is( ${$src->text()}, 'Hello World', 'hello world' );
ok( $src->fresh(), 'hello world source is fresh' );
$src = $prov->fetch('waz') || die $prov->error();
is( ${$src->text()}, 'Goodbye World', 'goodbye world' );
ok( $src->fresh(), 'goodbye world source is fresh' );
#------------------------------------------------------------------------
# test subclass fetch() method
#------------------------------------------------------------------------
ok( ! $prov->fetch('foo'), 'no fetch' );
is( $prov->error(), 'foo not found',
'foo not found' );
package Provider1;
use base qw( Template::Provider );
sub fetch {
my ($self, $name, $opts) = @_;
return "fetch: $name";
}
package main;
$prov = Provider1->new({
path => ['/foo', '/bar'],
debug => $DEBUG,
}) || die Provider->error();
my $result = $prov->fetch('wiz') || die $prov->error();
is( $result, 'fetch: wiz', 'fetch wiz' );
#------------------------------------------------------------------------
# test subclass fetch_path() method
#------------------------------------------------------------------------
our @DATA;
package Provider2;
use base qw( Template::Provider );
sub fetch_path {
my ($self, $path, $opts) = @_;
push(@DATA, $path);
return 0;
}
package main;
$prov = Provider2->new({
path => ['/foo', '/bar'],
debug => $DEBUG,
}) || die Provider->error();
$result = $prov->fetch('waz');
is( $result, 0, 'fetch_path() provider declined' );
is( $DATA[0], '/foo/waz', 'got /foo/waz path' );
is( $DATA[1], '/bar/waz', 'got /bar/waz path' );
__END__
# Local Variables:
# mode: perl
# perl-indent-level: 4
# indent-tabs-mode: nil
# End:
#
# vim: expandtab shiftwidth=4: