CatalystX::CRUD::Test::Controller - mock controller class for testing CatalystX::CRUD packages

 package MyApp::Controller::Foo;
 use strict;
 use base qw( CatalystX::CRUD::Test::Controller );

 use MyForm;

 __PACKAGE__->config(
    form_class            => 'MyForm',
    form_fields           => [qw( one two three )],
    init_form             => 'init_with_foo',
    init_object           => 'foo_from_form',
    default_template      => 'no/such/file',
    model_name            => 'Foo',
    primary_key           => 'id',
    view_on_single_result => 0,
    page_size             => 50,
    allow_GET_writes      => 0,
 );

 1;

 

    perldoc CatalystX::CRUD

package CatalystX::CRUD::Test::Controller;
use strict;
use warnings;
use base qw( CatalystX::CRUD::Controller );
use Carp;
use Data::Dump;
use mro 'c3';

__PACKAGE__->mk_accessors( qw( form_fields ) );

our $VERSION = '0.51';

sub form_to_object {
    my ( $self, $c ) = @_;
    my $form      = $c->stash->{form};
    my $obj       = $c->stash->{object};
    my $obj_meth  = $self->init_object;
    my $form_meth = $self->init_form;

    # id always comes from url but not necessarily from form
    my $id = $c->stash->{object_id};

    # initialize the form with the object's values
    $form->$form_meth($obj);

    # set param values from request
    $form->params( $c->req->params );

    # override form's values with those from params
    # no_clear is important because we already initialized with object
    # and we do not want to undo those mods.
    $form->init_fields( no_clear => 1 );

    # return if there was a problem with any param values
    unless ( $form->validate() ) {
        $c->stash->{error} = $form->error;    # NOT throw_error()
        $c->stash->{template} ||= $self->default_template;    # MUST specify
        return 0;
    }

    # re-set object's values from the now-valid form
    $form->$obj_meth($obj);

    return $obj;
}

sub form {
    my ( $self, $c ) = @_;
    my $form_class = $self->form_class;
    my $arg        = { fields => $self->form_fields };
    my $form       = $form_class->new($arg);
    return $form;
}

sub end : Private {
    my ( $self, $c ) = @_;
    if ( defined $c->stash->{object} ) {
        $c->res->body( $self->serialize_object( $c, $c->stash->{object} ) );
    }
    elsif ( defined $c->stash->{results} ) {
        my @body;
        while ( my $result = $c->stash->{results}->next ) {
            push( @body, $self->serialize_object( $c, $result ) );
        }
        $c->res->body( join( "\n", @body ) );
    }
    if ( $self->has_errors($c) ) {
        my $err = join( "\n", @{ $c->error } );
        $c->log->error($err) if $c->debug;
        $c->res->body($err);
        $c->res->status(500);
        $c->clear_errors;
    }
}

sub serialize_object {
    my ( $self, $c, $object ) = @_;
    my $fields = $self->form_fields;
    my $serial = {};
    for my $f (@$fields) {
        $serial->{$f} = defined $object->$f ? $object->$f . '' : undef;
    }
    return Data::Dump::dump($serial);
}

1;

__END__