[catagits/Reaction.git] / t / lib / RTest / InterfaceModel / Reflector / DBIC.pm

package RTest::InterfaceModel::Reflector::DBIC;

use base qw/Reaction::Test::WithDB Reaction::Object/;
use Reaction::Class;
use Class::MOP ();
use ComponentUI::TestModel;
use Test::More ();
use Reaction::InterfaceModel::Reflector::DBIC;

has '+schema_class' => (default => sub { 'RTest::TestDB' });

has im_schema => (is =>'ro', isa => 'RTest::TestIM', lazy_build => 1);

#at the moment I am only testing with the "reflect all" functionality
#when I have time I will write test cases that cover all the other bases
#it's just kind of a pain in the ass right now and I am behind on a lot of other shit.

sub _build_im_schema{
  my $self = shift;

  my $reflector = Reaction::InterfaceModel::Reflector::DBIC->new;

  $reflector->reflect_schema(
                             model_class  => 'RTest::TestIM',
                             schema_class => 'RTest::TestDB',
                             sources => [qw/Foo Bar Baz/]
                           );
  my (@dm) = RTest::TestIM->domain_models;
  Test::More::ok(@dm == 1, 'Correct number of Domain Models');
  my $dm = shift @dm;
  RTest::TestIM->new($dm->name => $self->schema);
}

sub test_classnames : Tests{
  my $self = shift;

  my $reflector = Reaction::InterfaceModel::Reflector::DBIC->new;


  Test::More::is(
                 $reflector->class_name_from_source_name('RTest::__TestIM','Foo'),
                 'RTest::__TestIM::Foo',
                 'Correct naming scheme for submodels'
                );
  Test::More::is(
                 $reflector->class_name_for_collection_of('RTest::__TestIM::Foo'),
                 'RTest::__TestIM::Foo::Collection',
                 'Correct naming scheme for submodel collections'
                );
}

sub test_reflect_schema :Tests {
  my $self = shift;
  my $s = $self->im_schema;

  Test::More::isa_ok( $s, 'Reaction::InterfaceModel::Object', 'Correct base' );

  my %pa = map{$_->name => $_ } $s->parameter_attributes;
  Test::More::ok(keys %pa == 3,  'Correct number of Parameter Attributes');

  Test::More::ok($pa{Foo} && $pa{'Bar'} && $pa{'Baz'},
                 'Parameter Attributes named correctly');

  for my $submodel (values %pa){
    Test::More::ok(
                   $submodel->_isa_metadata->isa('Reaction::InterfaceModel::Collection::Virtual::ResultSet'),
                   'Parameter Attribute typed correctly'
                  );
  }

  Test::More::can_ok($s, qw/foo_collection bar_collection baz_collection/);

  for ( qw/Foo Bar Baz/ ){
    Test::More::ok(
                   Class::MOP::is_class_loaded("RTest::TestIM::${_}"),
                   "Successfully created ${_} IM class"
                  );
    Test::More::ok(
                   Class::MOP::is_class_loaded("RTest::TestIM::${_}::Collection"),
                   "Successfully created ${_} IM class Collection"
                  );
  }
}


sub test_add_source_to_model :Tests {
  my $self = shift;
  my $s = $self->im_schema;

  for (qw/Foo Bar Baz /) {
    my $attr = $s->meta->find_attribute_by_name($_);
    my $reader = $_;
    $reader =~ s/([a-z0-9])([A-Z])/${1}_${2}/g ;
    $reader = lc($reader) . "_collection";

    Test::More::ok( $attr->is_required,           "${_} is required");
    Test::More::ok( $attr->has_reader,            "${_} has a reader");
    Test::More::ok( $attr->has_predicate,         "${_} has a predicate");
    Test::More::ok( $attr->has_domain_model,      "${_} has a domain_model");
    Test::More::ok( $attr->has_default,           "${_} has a default");
    Test::More::ok( $attr->is_default_a_coderef,  "${_}'s defaultis a coderef");
    Test::More::is( $attr->reader,   $reader,     "Correct ${_} reader");
    SKIP: {
      Test::More::skip "Not working", 1;
      Test::More::is( $attr->domain_model, "_rtest_testdb_store", "Correct ${_} domain_model");
    }
    Test::More::isa_ok(
                       $s->$reader,
                       "RTest::TestIM::${_}::Collection",
                       "${_} default method works"
                      );

  }
}

sub test_reflect_collection_for :Tests{
  my $self = shift;
  my $s = $self->im_schema;

  for ( qw/Foo Bar Baz/ ){
    my $reader = $s->meta->find_attribute_by_name($_)->reader;
    my $collection = $s->$reader;

    Test::More::is(
                   $collection->meta->name,
                   "RTest::TestIM::${_}::Collection",
                   "Correct Classname"
                  );
    Test::More::isa_ok(
                       $collection,
                       'Reaction::InterfaceModel::Collection',
                       "Collection ISA Collection"
                      );
    Test::More::isa_ok(
                       $collection,
                       'Reaction::InterfaceModel::Collection::Virtual',
                       "Collection ISA virtual collection"
                      );
    Test::More::isa_ok(
                       $collection,
                       'Reaction::InterfaceModel::Collection::Virtual::ResultSet',
                       "Collection ISA virtual resultset"
                      );
    SKIP: {
      Test::More::skip 'Does not work', 2;
      Test::More::can_ok($collection, '_build__im_class');
      Test::More::is(
                   $collection->_build__im_class,
                   "RTest::TestIM::${_}",
                   "Collection has correct _im_class"
                  );
    }
  }
}

sub test_reflect_submodel :Tests{
  my $self = shift;
  my $s = $self->im_schema;

  for my $sm ( qw/Foo Bar Baz/ ){
    my $reader = $s->meta->find_attribute_by_name($sm)->reader;
    my $collection = $s->$reader;
    my ($member) = $collection->members;
    Test::More::ok($member, "Successfully retrieved member");
    Test::More::isa_ok(
                       $member,
                       "Reaction::InterfaceModel::Object",
                       "Member isa IM::Object"
                      );
    SKIP: {
      Test::More::skip 'Attribute does not exist', 1;
      Test::More::isa_ok($member, $collection->_im_class);
    }
    
    my (@dm) = $member->domain_models;
    Test::More::ok(@dm == 1, 'Correct number of Domain Models');
    my $dm = shift @dm;

    my $dm_name = Reaction::InterfaceModel::Reflector::DBIC
      ->dm_name_from_source_name($sm);

    Test::More::is($dm->_is_metadata, "rw", "Correct is metadata");
    Test::More::ok($dm->is_required,  "DM is_required");
    Test::More::is($dm->name, $dm_name, "Correct DM name");
    Test::More::can_ok($member, "inflate_result");
    SKIP: {
      Test::More::skip 'Does not exist', 1;
      Test::More::is(
                   $dm->_isa_metadata,
                   "RTest::TestDB::${sm}",
                   "Correct isa metadata"
                  );
    }

    my %attrs = map { $_->name => $_ } $member->parameter_attributes;
    my $target;
    if(   $sm eq "Bar"){$target = 4; }
    elsif($sm eq "Baz"){$target = 5; }
    elsif($sm eq "Foo"){$target = 5; }
    Test::More::is( scalar keys %attrs, $target, "Correct # of attributes for $sm");

    for my $attr_name (keys %attrs){
      my $attr = $attrs{$attr_name};
      Test::More::ok($attr->is_lazy,                "is lazy");
      Test::More::ok($attr->is_required,            "is required");
      Test::More::ok($attr->has_clearer,            "has clearer");
      Test::More::ok($attr->has_default,            "has defau;t");
      Test::More::ok($attr->has_predicate,          "has predicate");
      Test::More::ok($attr->has_domain_model,       "has domain model");
      Test::More::ok($attr->has_orig_attr_name,     "has orig attr name");
      Test::More::ok($attr->is_default_a_coderef,   "default is coderef");
      Test::More::is($attr->_is_metadata,  "ro",    "Correct is metadata");
      Test::More::is($attr->domain_model, $dm_name, "Correct domain model");
      Test::More::is($attr->orig_attr_name, $attr_name, "Correct orig attr name");
    }

    SKIP: {
      if($sm eq "Foo"){
        Test::More::skip '_isa_metadata does not exist', 4;
        
        Test::More::is($attrs{id}->_isa_metadata, "Int", "Correct id isa metadata");
        Test::More::is($attrs{first_name}->_isa_metadata, "Reaction::Types::Core::NonEmptySimpleStr", "Correct first_name isa metadata");
        Test::More::is($attrs{last_name}->_isa_metadata,  "Reaction::Types::Core::NonEmptySimpleStr", "Correct last_name isa metadata");
        Test::More::is(
                       $attrs{baz_list}->_isa_metadata,
                       "RTest::TestIM::Baz::Collection",
                       "Correct baz_list isa metadata"
                      );
      } elsif($sm eq 'Bar'){
        Test::More::skip '_isa_metadata does not exist', 4;
        
        Test::More::is($attrs{name}->_isa_metadata, "Reaction::Types::Core::NonEmptySimpleStr", "Correct name isa metadata");
        Test::More::is($attrs{foo}->_isa_metadata, "RTest::TestIM::Foo", "Correct foo isa metadata");
        Test::More::is($attrs{published_at}->_isa_metadata, "DateTime",  "Correct published_at isa metadata");
        Test::More::is($attrs{avatar}->_isa_metadata, "File",            "Correct avatar isa metadata");
      } elsif($sm eq "Baz"){
        Test::More::skip '_isa_metadata does not exist', 3;
        
        Test::More::is($attrs{id}->_isa_metadata, "Int", "Correct id isa metadata");
        Test::More::is($attrs{name}->_isa_metadata, "Reaction::Types::Core::NonEmptySimpleStr", "Correct name isa metadata");
        Test::More::is(
                       $attrs{foo_list}->_isa_metadata,
                       "RTest::TestIM::Foo::Collection",
                       "Correct foo_list isa metadata"
                      );
      }
    }

  }
}

sub test_reflect_submodel_action :Tests{
  my $self = shift;
  my $s = $self->im_schema;

  for my $sm ( qw/Foo Bar Baz/ ){
    my $reader = $s->meta->find_attribute_by_name($sm)->reader;
    my $collection = $s->$reader;
    my ($member) = $collection->members;
    Test::More::ok($member, "Successfully retrieved member");
    Test::More::isa_ok(
                       $member,
                       "Reaction::InterfaceModel::Object",
                       "Member isa IM::Object"
                      );
    SKIP: {
      Test::More::skip 'Does not exist any more', 1;
      Test::More::isa_ok($member, $collection->_im_class);
    }
    
    my $ctx = $self->simple_mock_context;
    foreach my $action_name (qw/Update Delete DeleteAll Create/){

      my $target_im = $action_name =~ /(?:Create|DeleteAll)/ ? $collection : $member;
      my $action = $target_im->action_for($action_name, ctx => $ctx);

      Test::More::isa_ok( $action, "Reaction::InterfaceModel::Action",
                          "Create action isa Action" );
      Test::More::is(
                     $action->meta->name,
                     "RTest::TestIM::${sm}::Action::${action_name}",
                     "${action_name} action has correct name"
                    );

      my $base = 'Reaction::InterfaceModel::Action::DBIC'.
        ($action_name =~ /(?:Create|DeleteAll)/
         ? "::ResultSet::${action_name}" : "::Result::${action_name}");
      Test::More::isa_ok($action, $base, "${action_name} has correct base");


      my %attrs = map { $_->name => $_ } $action->parameter_attributes;
      my $attr_num;
      if($action_name =~ /Delete/){next; }
      elsif($sm eq "Bar"){$attr_num = 4; }
      elsif($sm eq "Baz"){$attr_num = 4; }
      elsif($sm eq "Foo"){$attr_num = 3; }
      Test::More::is( scalar keys %attrs, $attr_num, "Correct # of attributes for $sm");
      if($attr_num != keys %attrs ){
        print STDERR "\t..." . join ", ", keys %attrs, "\n";
      }

      for my $attr_name (keys %attrs){
        my $attr = $attrs{$attr_name};
        Test::More::ok($attr->has_predicate,        "has predicate");
        Test::More::is($attr->_is_metadata,  "rw",  "Correct is metadata");
        if ($attr->is_required){
          Test::More::ok($attr->is_lazy,     "is lazy");
          Test::More::ok($attr->has_default, "has default");
          Test::More::ok($attr->is_default_a_coderef, "default is coderef");
        }
      }

      SKIP: {
        if($sm eq "Foo"){
          Test::More::skip '_isa_metadata no longer exists', 3;
          
          Test::More::is($attrs{first_name}->_isa_metadata, "Reaction::Types::Core::NonEmptySimpleStr", "Correct first_name isa metadata");
          Test::More::is($attrs{last_name}->_isa_metadata,  "Reaction::Types::Core::NonEmptySimpleStr", "Correct last_name isa metadata");
          Test::More::is($attrs{baz_list}->_isa_metadata,  "ArrayRef", "Correct baz_list isa metadata");
        } elsif($sm eq 'Bar'){
          Test::More::skip '_isa_metadata no longer exists', 4;
          
          Test::More::is($attrs{name}->_isa_metadata, "Reaction::Types::Core::NonEmptySimpleStr",  "Correct name isa metadata");
          Test::More::is($attrs{foo}->_isa_metadata,  "RTest::TestDB::Foo", "Correct foo isa metadata");
          Test::More::is($attrs{published_at}->_isa_metadata, "DateTime",   "Correct published_at isa metadata");
          Test::More::is($attrs{avatar}->_isa_metadata, "File",             "Correct avatar isa metadata");
        } elsif($sm eq "Baz"){
          Test::More::skip '_isa_metadata no longer exists', 1;
          
          Test::More::is($attrs{name}->_isa_metadata, "Reaction::Types::Core::NonEmptySimpleStr",  "Correct name isa metadata");
        }
      }
    }
  }
}

1;
Commit	Line	Data
7adfd53f	1	package RTest::InterfaceModel::Reflector::DBIC;
	2
	3	use base qw/Reaction::Test::WithDB Reaction::Object/;
	4	use Reaction::Class;
	5	use Class::MOP ();
	6	use ComponentUI::TestModel;
	7	use Test::More ();
	8	use Reaction::InterfaceModel::Reflector::DBIC;
	9
	10	has '+schema_class' => (default => sub { 'RTest::TestDB' });
	11
	12	has im_schema => (is =>'ro', isa => 'RTest::TestIM', lazy_build => 1);
	13
	14	#at the moment I am only testing with the "reflect all" functionality
	15	#when I have time I will write test cases that cover all the other bases
	16	#it's just kind of a pain in the ass right now and I am behind on a lot of other shit.
	17
89939ff9	18	sub _build_im_schema{
7adfd53f	19	my $self = shift;
7adfd53f	20
f670cfd0	21	my $reflector = Reaction::InterfaceModel::Reflector::DBIC->new;
7adfd53f	22
f670cfd0	23	$reflector->reflect_schema(
	24	model_class => 'RTest::TestIM',
	25	schema_class => 'RTest::TestDB',
	26	sources => [qw/Foo Bar Baz/]
7adfd53f	27	);
	28	my (@dm) = RTest::TestIM->domain_models;
	29	Test::More::ok(@dm == 1, 'Correct number of Domain Models');
	30	my $dm = shift @dm;
7adfd53f	31	RTest::TestIM->new($dm->name => $self->schema);
	32	}
	33
	34	sub test_classnames : Tests{
	35	my $self = shift;
	36
f670cfd0	37	my $reflector = Reaction::InterfaceModel::Reflector::DBIC->new;
7adfd53f	38
7adfd53f	39
7adfd53f	40	Test::More::is(
f670cfd0	41	$reflector->class_name_from_source_name('RTest::__TestIM','Foo'),
7adfd53f	42	'RTest::__TestIM::Foo',
	43	'Correct naming scheme for submodels'
	44	);
7adfd53f	45	Test::More::is(
f670cfd0	46	$reflector->class_name_for_collection_of('RTest::__TestIM::Foo'),
7adfd53f	47	'RTest::__TestIM::Foo::Collection',
	48	'Correct naming scheme for submodel collections'
	49	);
	50	}
	51
f670cfd0	52	sub test_reflect_schema :Tests {
7adfd53f	53	my $self = shift;
	54	my $s = $self->im_schema;
	55
f670cfd0	56	Test::More::isa_ok( $s, 'Reaction::InterfaceModel::Object', 'Correct base' );
7adfd53f	57
	58	my %pa = map{$_->name => $_ } $s->parameter_attributes;
	59	Test::More::ok(keys %pa == 3, 'Correct number of Parameter Attributes');
	60
	61	Test::More::ok($pa{Foo} && $pa{'Bar'} && $pa{'Baz'},
	62	'Parameter Attributes named correctly');
	63
	64	for my $submodel (values %pa){
	65	Test::More::ok(
	66	$submodel->_isa_metadata->isa('Reaction::InterfaceModel::Collection::Virtual::ResultSet'),
	67	'Parameter Attribute typed correctly'
	68	);
	69	}
	70
	71	Test::More::can_ok($s, qw/foo_collection bar_collection baz_collection/);
	72
	73	for ( qw/Foo Bar Baz/ ){
	74	Test::More::ok(
	75	Class::MOP::is_class_loaded("RTest::TestIM::${_}"),
	76	"Successfully created ${_} IM class"
	77	);
	78	Test::More::ok(
	79	Class::MOP::is_class_loaded("RTest::TestIM::${_}::Collection"),
	80	"Successfully created ${_} IM class Collection"
	81	);
	82	}
	83	}
	84
	85
f670cfd0	86	sub test_add_source_to_model :Tests {
7adfd53f	87	my $self = shift;
	88	my $s = $self->im_schema;
	89
	90	for (qw/Foo Bar Baz /) {
	91	my $attr = $s->meta->find_attribute_by_name($_);
	92	my $reader = $_;
	93	$reader =~ s/([a-z0-9])([A-Z])/${1}_${2}/g ;
	94	$reader = lc($reader) . "_collection";
	95
	96	Test::More::ok( $attr->is_required, "${_} is required");
	97	Test::More::ok( $attr->has_reader, "${_} has a reader");
	98	Test::More::ok( $attr->has_predicate, "${_} has a predicate");
	99	Test::More::ok( $attr->has_domain_model, "${_} has a domain_model");
	100	Test::More::ok( $attr->has_default, "${_} has a default");
	101	Test::More::ok( $attr->is_default_a_coderef, "${_}'s defaultis a coderef");
	102	Test::More::is( $attr->reader, $reader, "Correct ${_} reader");
6ded0784	103	SKIP: {
	104	Test::More::skip "Not working", 1;
	105	Test::More::is( $attr->domain_model, "_rtest_testdb_store", "Correct ${_} domain_model");
	106	}
7adfd53f	107	Test::More::isa_ok(
	108	$s->$reader,
	109	"RTest::TestIM::${_}::Collection",
	110	"${_} default method works"
	111	);
	112
	113	}
	114	}
	115
	116	sub test_reflect_collection_for :Tests{
	117	my $self = shift;
	118	my $s = $self->im_schema;
	119
	120	for ( qw/Foo Bar Baz/ ){
	121	my $reader = $s->meta->find_attribute_by_name($_)->reader;
	122	my $collection = $s->$reader;
	123
	124	Test::More::is(
	125	$collection->meta->name,
	126	"RTest::TestIM::${_}::Collection",
	127	"Correct Classname"
	128	);
	129	Test::More::isa_ok(
	130	$collection,
	131	'Reaction::InterfaceModel::Collection',
	132	"Collection ISA Collection"
	133	);
	134	Test::More::isa_ok(
	135	$collection,
	136	'Reaction::InterfaceModel::Collection::Virtual',
	137	"Collection ISA virtual collection"
	138	);
	139	Test::More::isa_ok(
	140	$collection,
	141	'Reaction::InterfaceModel::Collection::Virtual::ResultSet',
	142	"Collection ISA virtual resultset"
	143	);
6ded0784	144	SKIP: {
	145	Test::More::skip 'Does not work', 2;
	146	Test::More::can_ok($collection, '_build__im_class');
	147	Test::More::is(
89939ff9	148	$collection->_build__im_class,
7adfd53f	149	"RTest::TestIM::${_}",
	150	"Collection has correct _im_class"
	151	);
6ded0784	152	}
7adfd53f	153	}
	154	}
	155
	156	sub test_reflect_submodel :Tests{
	157	my $self = shift;
	158	my $s = $self->im_schema;
	159
	160	for my $sm ( qw/Foo Bar Baz/ ){
	161	my $reader = $s->meta->find_attribute_by_name($sm)->reader;
	162	my $collection = $s->$reader;
	163	my ($member) = $collection->members;
	164	Test::More::ok($member, "Successfully retrieved member");
	165	Test::More::isa_ok(
	166	$member,
	167	"Reaction::InterfaceModel::Object",
	168	"Member isa IM::Object"
	169	);
6ded0784	170	SKIP: {
	171	Test::More::skip 'Attribute does not exist', 1;
	172	Test::More::isa_ok($member, $collection->_im_class);
	173	}
	174
7adfd53f	175	my (@dm) = $member->domain_models;
	176	Test::More::ok(@dm == 1, 'Correct number of Domain Models');
	177	my $dm = shift @dm;
	178
f670cfd0	179	my $dm_name = Reaction::InterfaceModel::Reflector::DBIC
f670cfd0	180	->dm_name_from_source_name($sm);
7adfd53f	181
	182	Test::More::is($dm->_is_metadata, "rw", "Correct is metadata");
	183	Test::More::ok($dm->is_required, "DM is_required");
	184	Test::More::is($dm->name, $dm_name, "Correct DM name");
	185	Test::More::can_ok($member, "inflate_result");
6ded0784	186	SKIP: {
	187	Test::More::skip 'Does not exist', 1;
	188	Test::More::is(
7adfd53f	189	$dm->_isa_metadata,
	190	"RTest::TestDB::${sm}",
	191	"Correct isa metadata"
	192	);
6ded0784	193	}
7adfd53f	194
	195	my %attrs = map { $_->name => $_ } $member->parameter_attributes;
	196	my $target;
	197	if( $sm eq "Bar"){$target = 4; }
99535516	198	elsif($sm eq "Baz"){$target = 5; }
6ded0784	199	elsif($sm eq "Foo"){$target = 5; }
6ded0784	200	Test::More::is( scalar keys %attrs, $target, "Correct # of attributes for $sm");
7adfd53f	201
	202	for my $attr_name (keys %attrs){
	203	my $attr = $attrs{$attr_name};
	204	Test::More::ok($attr->is_lazy, "is lazy");
	205	Test::More::ok($attr->is_required, "is required");
	206	Test::More::ok($attr->has_clearer, "has clearer");
	207	Test::More::ok($attr->has_default, "has defau;t");
	208	Test::More::ok($attr->has_predicate, "has predicate");
	209	Test::More::ok($attr->has_domain_model, "has domain model");
	210	Test::More::ok($attr->has_orig_attr_name, "has orig attr name");
	211	Test::More::ok($attr->is_default_a_coderef, "default is coderef");
	212	Test::More::is($attr->_is_metadata, "ro", "Correct is metadata");
	213	Test::More::is($attr->domain_model, $dm_name, "Correct domain model");
	214	Test::More::is($attr->orig_attr_name, $attr_name, "Correct orig attr name");
	215	}
	216
6ded0784	217	SKIP: {
	218	if($sm eq "Foo"){
	219	Test::More::skip '_isa_metadata does not exist', 4;
	220
	221	Test::More::is($attrs{id}->_isa_metadata, "Int", "Correct id isa metadata");
	222	Test::More::is($attrs{first_name}->_isa_metadata, "Reaction::Types::Core::NonEmptySimpleStr", "Correct first_name isa metadata");
	223	Test::More::is($attrs{last_name}->_isa_metadata, "Reaction::Types::Core::NonEmptySimpleStr", "Correct last_name isa metadata");
	224	Test::More::is(
	225	$attrs{baz_list}->_isa_metadata,
	226	"RTest::TestIM::Baz::Collection",
	227	"Correct baz_list isa metadata"
	228	);
	229	} elsif($sm eq 'Bar'){
	230	Test::More::skip '_isa_metadata does not exist', 4;
	231
	232	Test::More::is($attrs{name}->_isa_metadata, "Reaction::Types::Core::NonEmptySimpleStr", "Correct name isa metadata");
	233	Test::More::is($attrs{foo}->_isa_metadata, "RTest::TestIM::Foo", "Correct foo isa metadata");
	234	Test::More::is($attrs{published_at}->_isa_metadata, "DateTime", "Correct published_at isa metadata");
	235	Test::More::is($attrs{avatar}->_isa_metadata, "File", "Correct avatar isa metadata");
	236	} elsif($sm eq "Baz"){
	237	Test::More::skip '_isa_metadata does not exist', 3;
	238
	239	Test::More::is($attrs{id}->_isa_metadata, "Int", "Correct id isa metadata");
	240	Test::More::is($attrs{name}->_isa_metadata, "Reaction::Types::Core::NonEmptySimpleStr", "Correct name isa metadata");
	241	Test::More::is(
	242	$attrs{foo_list}->_isa_metadata,
	243	"RTest::TestIM::Foo::Collection",
	244	"Correct foo_list isa metadata"
	245	);
	246	}
7adfd53f	247	}
	248
	249	}
	250	}
	251
	252	sub test_reflect_submodel_action :Tests{
	253	my $self = shift;
	254	my $s = $self->im_schema;
	255
	256	for my $sm ( qw/Foo Bar Baz/ ){
	257	my $reader = $s->meta->find_attribute_by_name($sm)->reader;
	258	my $collection = $s->$reader;
	259	my ($member) = $collection->members;
	260	Test::More::ok($member, "Successfully retrieved member");
	261	Test::More::isa_ok(
	262	$member,
	263	"Reaction::InterfaceModel::Object",
	264	"Member isa IM::Object"
	265	);
6ded0784	266	SKIP: {
	267	Test::More::skip 'Does not exist any more', 1;
	268	Test::More::isa_ok($member, $collection->_im_class);
	269	}
	270
7adfd53f	271	my $ctx = $self->simple_mock_context;
89939ff9	272	foreach my $action_name (qw/Update Delete DeleteAll Create/){
7adfd53f	273
89939ff9	274	my $target_im = $action_name =~ /(?:Create\|DeleteAll)/ ? $collection : $member;
7adfd53f	275	my $action = $target_im->action_for($action_name, ctx => $ctx);
	276
	277	Test::More::isa_ok( $action, "Reaction::InterfaceModel::Action",
	278	"Create action isa Action" );
	279	Test::More::is(
	280	$action->meta->name,
	281	"RTest::TestIM::${sm}::Action::${action_name}",
	282	"${action_name} action has correct name"
	283	);
	284
89939ff9	285	my $base = 'Reaction::InterfaceModel::Action::DBIC'.
	286	($action_name =~ /(?:Create\|DeleteAll)/
	287	? "::ResultSet::${action_name}" : "::Result::${action_name}");
	288	Test::More::isa_ok($action, $base, "${action_name} has correct base");
7adfd53f	289
	290
	291	my %attrs = map { $_->name => $_ } $action->parameter_attributes;
	292	my $attr_num;
89939ff9	293	if($action_name =~ /Delete/){next; }
7adfd53f	294	elsif($sm eq "Bar"){$attr_num = 4; }
99535516	295	elsif($sm eq "Baz"){$attr_num = 4; }
7adfd53f	296	elsif($sm eq "Foo"){$attr_num = 3; }
6ded0784	297	Test::More::is( scalar keys %attrs, $attr_num, "Correct # of attributes for $sm");
7adfd53f	298	if($attr_num != keys %attrs ){
	299	print STDERR "\t..." . join ", ", keys %attrs, "\n";
	300	}
	301
	302	for my $attr_name (keys %attrs){
	303	my $attr = $attrs{$attr_name};
	304	Test::More::ok($attr->has_predicate, "has predicate");
	305	Test::More::is($attr->_is_metadata, "rw", "Correct is metadata");
	306	if ($attr->is_required){
	307	Test::More::ok($attr->is_lazy, "is lazy");
	308	Test::More::ok($attr->has_default, "has default");
	309	Test::More::ok($attr->is_default_a_coderef, "default is coderef");
	310	}
	311	}
	312
6ded0784	313	SKIP: {
	314	if($sm eq "Foo"){
	315	Test::More::skip '_isa_metadata no longer exists', 3;
	316
	317	Test::More::is($attrs{first_name}->_isa_metadata, "Reaction::Types::Core::NonEmptySimpleStr", "Correct first_name isa metadata");
	318	Test::More::is($attrs{last_name}->_isa_metadata, "Reaction::Types::Core::NonEmptySimpleStr", "Correct last_name isa metadata");
	319	Test::More::is($attrs{baz_list}->_isa_metadata, "ArrayRef", "Correct baz_list isa metadata");
	320	} elsif($sm eq 'Bar'){
	321	Test::More::skip '_isa_metadata no longer exists', 4;
	322
	323	Test::More::is($attrs{name}->_isa_metadata, "Reaction::Types::Core::NonEmptySimpleStr", "Correct name isa metadata");
	324	Test::More::is($attrs{foo}->_isa_metadata, "RTest::TestDB::Foo", "Correct foo isa metadata");
	325	Test::More::is($attrs{published_at}->_isa_metadata, "DateTime", "Correct published_at isa metadata");
	326	Test::More::is($attrs{avatar}->_isa_metadata, "File", "Correct avatar isa metadata");
	327	} elsif($sm eq "Baz"){
	328	Test::More::skip '_isa_metadata no longer exists', 1;
	329
	330	Test::More::is($attrs{name}->_isa_metadata, "Reaction::Types::Core::NonEmptySimpleStr", "Correct name isa metadata");
	331	}
7adfd53f	332	}
	333	}
	334	}
	335	}
	336
	337	1;