http://green.ebay.com/instantsale/

Parent Community: http://apps.facebook.com/aeonwk-parents/

http://code.google.com/p/ebay-api-simple/

http://search.cpan.org/~tkeefer/eBay-API-Simple-0.17/

use eBay::API::Simple::Finding;

my $call = eBay::API::Simple::Finding->new( {
   appid   => 'myappid',
} );

$call->execute( 'findItemsByKeywords', { keywords => 'shoe' } );

if ( $call->has_error() ) {
   die "Call Failed:" . $call->errors_as_string();
}

# getters for the response DOM or Hash
my $dom  = $call->response_dom();
my $hash = $call->response_hash();

my @nodes = $dom->findnodes(
  '//item'
);
foreach my $n ( @nodes ) {
  print $n->findvalue('title/text()') . "\n";
}

http://pypi.python.org/pypi/ebaysdk/0.0.2

http://developer.ebay.com/products/finding/

from ebaysdk import finding, tag, nodeText

f = finding()
f.execute('findItemsAdvanced', tag('keywords', 'shoes'))        
print f.v('itemSearchURL')'

items = f.response_dom().getElementsByTagName('item')
for item in items:
   print nodeText(item.getElementsByTagName('title')[0])

http://green.ebay.com

http://green.ebay.ca

field shipped {
  is             datetime;
  label          Shipped;
  html_form_type text;
  html_form_display_size 10;
  html_form_class `date-picker`;
  html_form_optional 1;
}

Gantry form method

{
  display_size => 10,
  name => 'shipped',
  class => 'date-picker',
  optional => 1,
  label => 'Shipped',
  type => 'text',
  is => 'datetime',
},

HTML

snippet from from the site wrapper

<script src="[% self.doc_rootp %]/js/jquery.js"
    charset="utf-8" type="text/javascript"></script>
<script src="[% self.doc_rootp %]/js/datePicker.js"
    charset="utf-8" type="text/javascript"></script>

<script>
    $(document).ready(init);
    function init() {
        $.datePicker.setDateFormat('mdy','/');
          $('input#shipped').datePicker();
}
</script>

 <input type="text" name="shipped" id="shipped" value="" />

 sub do_view {
    my( $self, $id ) = @_;

    my %params = $self->get_param_hash;

    my $sch  = $self->get_schema();
    my $blog = $sch->resultset( 'blog' )->find( $ident );

    my $captcha = Gantry::Utils::Captcha->new( 'mysecret' ); 

    $captcha->add( {
        base_url => $self->doc_rootp() . "/images",
        image    => 'captcha-image-1.jpg',
        key      => 'chair',
        label    => 'looks like a chair to me',
        alt_text => 'sometimes it feels reaally good to sit',
    } );

    $captcha->add( {
        base_url  => $self->doc_rootp() . "/images",
        image     => 'captcha-image-2.jpg',
        key       => 'yoda',
        label     => 'hrm ... yoda you are',
        alt_text  => 'use the force, Luke',
    } );

    $captcha->add( {
        base_url  => $self->doc_rootp() . "/images",
        image     => 'captcha-image-3.jpg',
        key       => 'biking',
        label     => 'biking is fun',
        alt_text  => 'two wheels and a seat',
    } );

    $captcha->shuffle();

    if ( $blog ) {
        $self->stash->view->template( 'blog.tt' );
        $self->stash->view->data( $blog );

        # munger the comment form
        my $form = Apps::Blogger::GEN::Blog::Comment::form( $self );

        my $munger = Gantry::Utils::FormMunger->new( $form );

        $munger->add_field_after( 'body', {
            type    => 'html',
            name    => 'captcha_image',
            label   => 'choose wisely',
            optional => 1,
            html    => $captcha->image_link,
        } );

        $munger->add_field_after( 'captcha_image', {
            class   => 'captcha-image',
            name    => 'captcha',
            type    => 'select',
            label   => ' ',
            options => $captcha->gantry_form_options(),
        } );

        $self->stash->view->form( $form );

        if ( $self->is_post() ) {

            if ( defined $params{cancel} ) {
                $self->relocate( $self->location );
            }

            my $results = Data::FormValidator->check(
                \%params,
                form_profile( $form->{fields} ),
            );

            my $has_errors = 0;

            unless ( $captcha->valid( $params{captcha} ) ) {
                $results->{invalid}{captcha} = "try again";
                $has_errors = 1;
            }

            $has_errors = 1 if ( $results->has_invalid );
            $has_errors = 1 if ( $results->has_missing );

            # Form has errors
            if ( $has_errors ) {
                $self->stash->view->form->results( $results );
            }
            # Form looks good, make update
            else {
                clean_params( \%params, $form->{fields} );

                delete( $params{submit} );
                delete( $params{captcha} ); # be sure to delete

                $params{created} =  $self->date_now;

                my $comment = $sch->resultset( 'comment' )->create(
                    \%params
                );

            }
        }
    }
    else {
        die "blog entry not found\n";
    }
  }

I see it this way; there are two basic ways to run the class tests.
1) Run the tests for a single class from the command line

perl -Ilib -mSunflower::Queue -e 'Sunflower::Queue->run_tests;'

2) Create a batch test script (01class.t) to crawl your distribution
looking for *.pm and execute the class run_tests method

package Sunflower::Queue;

use strict;
use warnings;
use Amazon::SQS::Simple;

sub new {
   my ( $class, $access_key, $secret_key ) = ( shift, shift, shift );

   $access_key ||= 'somekey';
   $secret_key ||= 'secretkey';

   my $self = {};
   bless( $self, $class );

   # create and instance of SQS
   $self->queue_service(
       Amazon::SQS::Simple->new( $access_key, $secret_key )
   );

   return $self;
}

sub run_tests {
   my $class = shift;
   require Test::Builder;

   my $test = Test::Builder->new();
   $test->no_plan;
   $test->diag( 'testing ' . __PACKAGE__ );

   my $o = __PACKAGE__->new();

   for ( 1 .. 10 ) {
      $test->is_eq( $o->test_method, 'tim', "test return value" );
   }
}

# sample method
sub test_method {
   my $self = shift;
   return 'tim';
}

# Queue stuff
sub ListQueues {
   my $self = shift;
   $self->queue_service->ListQueues( @_ );
}