Menu
▾
▴
[Everydevel-opers] SF.net SVN: everydevel: [967] trunk/ebase
|
From: <pau...@us...> - 2007-06-06 10:01:53
|
Revision: 967
http://svn.sourceforge.net/everydevel/?rev=967&view=rev
Author: paul_the_nomad
Date: 2007-06-06 03:01:52 -0700 (Wed, 06 Jun 2007)
Log Message:
-----------
Code to test nodebase nodes against a nodeball
Modified Paths:
--------------
trunk/ebase/lib/Everything/Storage/Nodeball.pm
trunk/ebase/lib/Everything/Storage/Test/Nodeball.pm
Added Paths:
-----------
trunk/ebase/bin/verify_nodes.pl
Property Changed:
----------------
trunk/ebase/
Property changes on: trunk/ebase
___________________________________________________________________
Name: svk:merge
- 16c2b9cb-492b-4d64-9535-64d4e875048d:/wip/ebase:1015
a6810612-c0f9-0310-9d3e-a9e4af8c5745:/ebase/offline:17930
+ 16c2b9cb-492b-4d64-9535-64d4e875048d:/wip/ebase:1016
a6810612-c0f9-0310-9d3e-a9e4af8c5745:/ebase/offline:17930
Added: trunk/ebase/bin/verify_nodes.pl
===================================================================
--- trunk/ebase/bin/verify_nodes.pl (rev 0)
+++ trunk/ebase/bin/verify_nodes.pl 2007-06-06 10:01:52 UTC (rev 967)
@@ -0,0 +1,130 @@
+#!/usr/bin/perl
+
+use strict;
+use warnings;
+
+use Everything::NodeBase;
+use Everything::Storage::Nodeball;
+use Everything::XML::Node;
+use Text::Reform;
+use Everything::CmdLine qw/get_options usage_options make_nodebase/;
+use Carp;
+
+my $opts = get_options();
+
+usage_options(
+"\nUsage:\n\n\t$0 [options] <nodeball path>\n\nThe <nodeball path> argument is the path to the file of the nodeball we are verifying. \n\n"
+) unless @ARGV >= 1;
+
+my $nb = make_nodebase($opts);
+
+die "No Nodebase" unless $nb;
+
+my $ball =
+ Everything::Storage::Nodeball->new( nodebase => $nb, nodeball => $ARGV[0] );
+
+my ( $in_nodeball, $in_nodebase, $diffs ) = $ball->verify_nodes;
+
+if ( !@$in_nodeball && !@$in_nodebase && !@$diffs ) {
+ print "OK\n";
+ exit;
+}
+
+my $head_form =
+ " |||||||||||||||||||||||||||||||||||||||||||||||||||| ";
+my $head_column =
+"[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[ [[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[";
+my $column =
+"ball\> [[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[ base\> [[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[";
+
+print form $head_form, "The following nodes are not in the Nodebase"
+ if @$in_nodeball;
+
+foreach (@$in_nodeball) {
+ print form $column,
+ sprintf( "Title: '%s' Type: '%s'\n", $_->get_title, $_->get_nodetype ),
+ "Not in nodebase.";
+}
+print "\n\n";
+
+print form $head_form, "The following nodes are not in the Nodeball"
+ if @$in_nodebase;
+
+foreach (@$in_nodebase) {
+ print form $column, "Not in nodeball",
+ sprintf( "Title: '%s' Type: '%s'\n",
+ $_->get_title, $_->get_type->get_title );
+}
+
+print "\n\n";
+
+
+foreach (@$diffs) {
+
+ my $diff = $$_[1];
+ my $xmlnode = $$_[0];
+
+ print form $head_form, "For Node "
+ . sprintf( "Title: '%s' Type: '%s'\n",
+ $xmlnode->get_title, $xmlnode->get_nodetype );
+
+ foreach ( grep { $_->is_attribute || $_->is_var } @$diff ) {
+
+ my $att_name = $_->get_name || '';
+
+ my $attribute_type = $_->is_attribute ? 'attribute' : 'var';
+
+ if ( !$_->is_noderef ) {
+
+ my $xmlcontent = $_->get_xmlnode_content || '';
+ my @xmllines = split /\n/, $xmlcontent;
+
+ my @baselines = split /\n/, $_->get_nb_node_content || '';
+ print form $head_form, "$attribute_type '$att_name'\n";
+
+ print form $head_column,
+ "In the Nodeball\n$attribute_type '$att_name' is:",
+ "In the Nodebase\n$attribute_type '$att_name' is:";
+ print "\n\n";
+ print form $column, \@xmllines, \@baselines;
+
+ print "\n\n";
+ }
+ else {
+ my $name = $_->get_xmlnode_ref_name || '';
+ my $type = $_->get_xmlnode_ref_type || '';
+
+ my $nb_name = $_->get_nb_node_ref_name || '';
+ my $nb_type = $_->get_nb_node_ref_type || '';
+
+ print form $head_form, "$attribute_type $att_name";
+ print form $column, "references '$name' of type '$type'",
+ "references '$nb_name' of type '$nb_type'\n\n";
+ print "\n\n";
+ }
+ }
+
+ foreach ( grep { $_->is_groupmember } @$diff ) {
+
+ my $in_nodeball = $_->get_xmlnode_additional;
+ my $in_nodebase = $_->get_nb_node_additional;
+
+ foreach (@$in_nodeball) {
+
+ print form $head_form,
+ sprintf( "A node '%s' of type '%s' is:", @$_{ 'title', 'type' } );
+ print form $column, "Is in the nodeball", "Not in the nodebase";
+ }
+
+ foreach (@$in_nodebase) {
+
+ print form $head_form,
+ sprintf( "A node '%s' of type '%s' is:",
+ $_->get_title, $_->get_type->get_title );
+ print form $column, "Not in the nodeball", "Is in the nodebase";
+ }
+
+ print "\n\n";
+ }
+
+}
Property changes on: trunk/ebase/bin/verify_nodes.pl
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Name: svn:eol-style
+ native
Modified: trunk/ebase/lib/Everything/Storage/Nodeball.pm
===================================================================
--- trunk/ebase/lib/Everything/Storage/Nodeball.pm 2007-06-06 10:01:25 UTC (rev 966)
+++ trunk/ebase/lib/Everything/Storage/Nodeball.pm 2007-06-06 10:01:52 UTC (rev 967)
@@ -790,74 +790,73 @@
=head2 C<verify_nodes>
Cycles through the nodeball and checks each node against what is in the nodebase. the Checks that a node in the nodeball is the same as the one in the nodebase.
-Returns an array ref of array refs.
+Returns a list of array refs.
-Each of the inner array refs are as follows:
+The first is a list of xmlnodes that don't have corresonding entries
+in the nodebase.
-If the node is in the nodeball but not in the nodebase:
+The second is a list of nodes that don't have corresonding xmlnodes
+in the nodeball.
-[ $xmlnode, undef ]
+The third is a list of Everything::Storage::Nodeball::Diff objects
+that set out that differences.
-If the node is in the nodebase (and listed as a member of the nodeball), but not in the nodeball:
+=cut
-[ undef, $node ]
-If the node is in the nodebase and nodeball, but there are differences:
+sub verify_nodes {
+ my ($self) = @_;
-[ $xmlnode, $diff_hash ]
+ my $nb = $self->get_nodebase;
-$diff_hash is a hash of the difference as returned by verify_node().
+ my $iterator = $self->make_node_iterator;
-=cut
+ my $nodebase_nodeball_group =
+ $nb->getNode( $self->nodeball_vars->{title}, 'nodeball' )
+ ->selectGroupArray;
+ ## get nodes in group;
-sub verify_nodes {
- my ( $self ) = @_;
+ my %nodebase_group = map {
+ my $n = $nb->getNode($_);
+ ( "$$n{title},$$n{type}{title}" => 1 );
+ } @$nodebase_nodeball_group;
- my $nb = $self->get_nodebase;
-
- my $iterator = $self->make_node_iterator;
-
my @diffs;
- my $nodebase_nodeball_group = $nb->getNode( $self->nodeball_vars->{title}, 'nodeball')->selectGroupArray;
+ my @in_nodeball;
- ## get nodes in group;
+ my @in_nodebase;
- my %nodebase_group = map { my $n = $nb->getNode( $_ );
- ("$$n{title},$$n{type}{title}" => 1);
- }
- @$nodebase_nodeball_group;
-
XMLNODE:
- while (my $xmlnode = $iterator->() ) {
+ while ( my $xmlnode = $iterator->() ) {
- my $title = $xmlnode->get_title;
- my $type = $xmlnode->get_nodetype;
- my $node = $self->get_nodebase->getNode( $title, $type );
+ my $title = $xmlnode->get_title;
+ my $type = $xmlnode->get_nodetype;
+ my $node = $self->get_nodebase->getNode( $title, $type );
- delete $nodebase_group{ "$title,$type" };
+ delete $nodebase_group{"$title,$type"};
- if ( ! $node) {
+ if ( !$node ) {
- push @diffs, [ $xmlnode, undef ];
- next XMLNODE;
- }
+ push @in_nodeball, $xmlnode;
+ next XMLNODE;
+ }
- if ( my $diff = $self->verify_node( $xmlnode, $node) ) {
+ if ( my $diff = $self->verify_node( $xmlnode, $node ) ) {
- push @diffs, [ $xmlnode, $diff ];
- next XMLNODE;
- }
+ push @diffs, [ $xmlnode, $diff ] ;
+ next XMLNODE;
+ }
}
foreach ( keys %nodebase_group ) {
- my ( $title, $type ) = split /,/, $_;
- push @diffs, [ undef, $nb->getNode( $title, $type ) ];
+ my ( $title, $type ) = split /,/, $_;
+ push @in_nodebase, $nb->getNode( $title, $type );
}
- return \@diffs;
+ return \@in_nodeball, \@in_nodebase, \@diffs;
}
=head2 C<verify_node>
@@ -866,34 +865,11 @@
First argument in the XML::Node object, the second one is the Everything::Node object.
-Returns a hash ref of differences. It has the the following structure.
+Returns an array ref of Everything::Storage::Nodeball::Diff objects.
-{
-
- attribute => { attributename => [ $xmlnode, $node, $attributetype ],
- attributename2 => [ $xmlnode, $node, 'noderef', $referenced_node ],
- ....
- },
-
- var => { varname => [ $xmlnode, $node, 'literal_value' ],
- varname2 => [ $xmlnode, $node, 'noderef', $referenced_node ],
- ....
- },
-
-
- groupmember => { membernodetype,nodetype => [ $xmlnode, $node, $referenced_node ],
- ....
- }
-
-}
-
=cut
-## Arguably, the return value is a little confusing and difficult to
-## unpack, so we should do itwith an Everything::Nodeball::Difference
-## object or something
-
sub verify_node {
my ( $self, $xmlnode, $node ) = @_;
@@ -903,7 +879,7 @@
### nodebae stored in $node
my $nb = $self->get_nodebase;
- my %differences;
+ my @differences;
## verify attributes
my $atts = $xmlnode->get_attributes;
@@ -912,116 +888,56 @@
my $node_title = $xmlnode->get_title;
my $node_type = $xmlnode->get_nodetype;
- my %attribute_differences;
+ foreach (@$atts) {
- foreach (@$atts) {
my $att_name = $_->get_name;
- my $att_type = $_->get_type;
+ my $diff = Everything::Storage::Nodeball::Diff->new( nodebase => $nb );
+ if ( $diff->check_attribute( $xmlnode, $node, $_ ) ) {
- if ( $att_type eq 'literal_value' ) {
+ push @differences, $diff;
+ }
- ## the line below makes undef an empty string to deal
- ## with the way database tables are created at the
- ## moment.
- my $content = defined $_->get_content ? $_->get_content : '';
-
- unless ( $node->{$att_name} eq $content ) {
- $attribute_differences{ $att_name } = [ $xmlnode, $node, $att_type ];
- }
-
- }
- else {
-
- my ($type_name) = split /,/, $_->get_type_nodetype;
- my $node_name = $_->get_content;
-
- my $wanted = $nb->getNode( $node_name, $type_name );
-
- unless ( $node->{$att_name} == $wanted->{node_id} ) {
- $attribute_differences{ $att_name } = [ $xmlnode, $node, $att_type, $wanted ];
- }
-
- }
- $differences{ attributes } = \%attribute_differences if %attribute_differences;
}
### verify vars
- my $vars = $xmlnode->get_vars;
+ my $vars = $xmlnode->get_vars;
if (@$vars) {
my $db_vars = $node->getVars;
- my %var_differences;
-
foreach (@$vars) {
- my $var_name = $_->get_name;
+ my $diff = Everything::Storage::Nodeball::Diff->new( nodebase => $nb );
+ if ( $diff->check_var( $xmlnode, $node, $_ ) ) {
- my $var_type = $_->get_type;
+ push @differences, $diff;
+ }
+ }
+ }
- if ( $var_type eq 'literal_value' ) {
- ## the line below makes undef an empty string to deal
- ## with the way database tables are created at the
- ## moment.
- my $content = defined $_->get_content ? $_->get_content : '';
-
-
- unless ( $db_vars->{$var_name} eq $content ) {
- $var_differences{ $var_name } = [ $xmlnode, $node, $var_type ];
- }
-
- }
- else {
-
- my ($type_name) = split /,/, $_->get_type_nodetype;
- my $node_name = $_->get_content;
-
- my $wanted = $nb->getNode( $node_name, $type_name );
-
- unless ( $db_vars->{$var_name} == $wanted->{node_id} ) {
- $var_differences{ $var_name } = [ $xmlnode, $node, $var_type, $wanted ];
- }
-
-
- }
- }
- $differences{ vars } = \%var_differences if %var_differences;
-
-
- }
## verify group members
my $members = $xmlnode->get_group_members;
if ( @$members ) {
-
- my %db_members = map { $_ => 1 } @{ $node->selectGroupArray };
- my %member_differences;
+ my $diff = Everything::Storage::Nodeball::Diff->new( nodebase => $nb );
+ if ( $diff->check_members( $xmlnode, $node ) ) {
- foreach (@$members) {
-
- my ($type_name) = split /,/, $_->get_type_nodetype;
- my $node_name = $_->get_name;
-
- my $wanted = $nb->getNode( $node_name, $type_name );
-
- unless ( $db_members{ $wanted->{node_id} } ) {
- $member_differences{"$node_name,$type_name" } = [ $xmlnode, $node, $wanted ];
+ push @differences, $diff;
}
- }
- $differences{groupmembers} = \%member_differences if %member_differences;
+
+ }
- }
- return \%differences if %differences;
+ return \@differences if @differences;
return;
}
@@ -1478,4 +1394,181 @@
return 1;
}
+package Everything::Storage::Nodeball::Diff;
+
+{
+
+use Object::InsideOut;
+
+my @nodebase :Field :Arg(nodebase) :Std(nodebase);
+
+my @name :Field :Arg(name) :Std(name); # for attributes and vars
+
+my @is_noderef :Field :Default(0) :Acc(is_noderef);
+
+my @is_var :Field :Default(0) :Acc(is_var);
+
+my @is_attribute :Field :Default(0) :Acc(is_attribute);
+
+my @is_groupmember :Field :Default(0) :Acc(is_groupmember);
+
+my @xmlnode :Field :Arg(xmlnode) :Std(xmlnode);
+
+my @nb_node :Field :arg(nb_node) :Std(nb_node);
+
+my @xmlnode_attribute :Field :Std(xmlnode_attribute) :Type(Everything::XML::Node::Attribute);
+
+my @xmlnode_content :Field :Std(xmlnode_content); #for literal content
+
+my @nb_node_content :Field :Std(nb_node_content); #for literal content
+
+my @xmlnode_ref_name :Field :Std(xmlnode_ref_name); #for noderefs
+
+my @nb_node_ref_name :Field :Std(nb_node_ref_name); #for noderefs
+
+my @xmlnode_ref_type :Field :Std(xmlnode_ref_type); #for noderefs
+
+my @nb_node_ref_type :Field :Std(nb_node_ref_type); #for noderefs
+
+my @xmlnode_additional :Field :Std(xmlnode_additional) :Type(list); # for group members
+
+my @nb_node_additional :Field :Std(nb_node_additional) :Type(list); # for group members
+
+}
+
+sub check_attribute {
+
+ my ( $self, $xmlnode, $nb_node, $xmlnode_attribute ) = @_;
+
+ my $nb = $self->get_nodebase;
+
+ $self->is_attribute(1);
+
+ $self->set_xmlnode($xmlnode);
+ $self->set_nb_node($nb_node);
+
+ my $name = $xmlnode_attribute->get_name;
+
+ $self->set_name($name);
+
+ my $method = 'get_' . $name;
+
+ my $nb_node_content = $nb_node->$method;
+
+ return $self->compare_data( $xmlnode_attribute, $nb_node_content );
+}
+
+sub check_var {
+
+ my ( $self, $xmlnode, $nb_node, $xmlnode_attribute ) = @_;
+
+ my $nb = $self->get_nodebase;
+
+ $self->is_var(1);
+
+ $self->set_xmlnode($xmlnode);
+ $self->set_nb_node($nb_node);
+
+ my $name = $xmlnode_attribute->get_name;
+
+ $self->set_name($name);
+
+ my $vars = $nb_node->getVars;
+
+ my $nb_node_content = $vars->{$name};
+
+ return $self->compare_data( $xmlnode_attribute, $nb_node_content );
+}
+
+sub compare_data {
+
+ my ( $self, $xmlnode_attribute, $nb_node_content ) = @_;
+
+ $nb_node_content ||= '';
+
+ my $nb = $self->get_nodebase;
+
+ my $att_type = $xmlnode_attribute->get_type;
+
+ if ( $att_type eq 'literal_value' ) {
+
+ $self->is_noderef(0);
+
+ my $xmlcontent = $xmlnode_attribute->get_content || '';
+
+ return if $xmlcontent eq $nb_node_content;
+
+ $self->set_xmlnode_content($xmlcontent);
+ $self->set_nb_node_content($nb_node_content);
+
+ }
+ else {
+
+ my ($type_name) = split /,/, $xmlnode_attribute->get_type_nodetype;
+ my $node_name = $xmlnode_attribute->get_content;
+
+ my $expected = $nb->getNode( $node_name, $type_name );
+
+ my $nb_ref = $self->get_nodebase->getNode($nb_node_content);
+
+ return
+ if $expected
+ && $nb_ref
+ && ( $expected->get_node_id == $nb_ref->get_node_id );
+
+ $self->is_noderef(1);
+
+ $self->set_xmlnode_ref_name($node_name);
+ $self->set_xmlnode_ref_type($type_name);
+ $self->set_nb_node_ref_name( $nb_ref->get_title ) if $nb_ref;
+ $self->set_nb_node_ref_type( $nb_ref->get_type->get_title ) if $nb_ref;
+
+ }
+
+ return $self;
+
+}
+
+sub check_members {
+
+ my ( $self, $xmlnode, $nb_node ) = @_;
+
+ my $nb = $self->get_nodebase;
+
+ my @db_members = @{ $nb_node->selectGroupArray }; # node_ids
+ my %db_members = map { $_ => 1 } @db_members;
+
+ my @in_nodeball;
+
+ my $members = $xmlnode->get_group_members;
+
+ MEMBER:
+ foreach (@$members) {
+
+ my ($type_name) = split /,/, $_->get_type_nodetype;
+ my $node_name = $_->get_name;
+
+ my $wanted = $nb->getNode( $node_name, $type_name );
+
+ next MEMBER if $wanted && delete $db_members{ $wanted->get_node_id };
+ push @in_nodeball, { name => $node_name, type => $type_name };
+
+ }
+
+ my @in_nodebase;
+ foreach ( keys %db_members ) {
+
+ my $member = $nb->getNode($_);
+ push @in_nodebase, $member;
+ }
+
+ return if !@in_nodebase && !@in_nodeball;
+
+ $self->is_groupmember(1);
+ $self->set_xmlnode_additional( @in_nodeball ) if @in_nodeball;
+ $self->set_nb_node_additional( @in_nodebase ) if @in_nodebase;
+
+ return $self;
+}
+
1;
Modified: trunk/ebase/lib/Everything/Storage/Test/Nodeball.pm
===================================================================
--- trunk/ebase/lib/Everything/Storage/Test/Nodeball.pm 2007-06-06 10:01:25 UTC (rev 966)
+++ trunk/ebase/lib/Everything/Storage/Test/Nodeball.pm 2007-06-06 10:01:52 UTC (rev 967)
@@ -864,7 +864,7 @@
}
-sub test_verify_nodes : Test(1) {
+sub test_verify_nodes : Test(3) {
my $self = shift;
my $instance = $self->{instance};
@@ -896,21 +896,20 @@
$mock->{title} = 'node title';
$mock->{type} = $mock;
- my $rv = $instance->verify_nodes;
+ my ( $in_nodeball, $in_nodebase, $diffs ) = $instance->verify_nodes;
+ is_deeply( $in_nodeball, [$mock], '...returns an array ref.' );
+
+ is_deeply( $in_nodebase, [$mock], '...returns an array ref.' );
+
is_deeply(
- $rv,
- [
- [ $mock, undef ],
- [ $mock, 'verified' ],
- [ $mock, 'verified' ],
- [ undef, $mock ]
- ],
+ $diffs,
+ [ [ $mock, 'verified' ], [ $mock, 'verified' ], ],
'...returns an array ref.'
);
}
-sub test_verify_node : Test(4) {
+sub test_verify_node : Test(19) {
my $self = shift;
my $instance = $self->{instance};
my $xmlnode = Test::MockObject->new;
@@ -921,6 +920,7 @@
$self->{mock}->set_always( getNode => $self->{mock} );
$self->{mock}->{title} = 3;
$self->{mock}->{node_id} = 123;
+ $mock->set_always( get_node_id => 123 );
$xmlnode->set_always( 'get_attributes', [ $xmlnode, $xmlnode ] );
@@ -929,51 +929,53 @@
$xmlnode->set_always( get_title => 'node name' );
$xmlnode->set_always( get_nodetype => 'a nodetype' );
- $xmlnode->set_series( get_name => 'attribute name', 'att2' );
+ $xmlnode->set_series( get_name => 'attribute_name', 'attribute_name','attribute_name','attribute_name', 'att2', 'att2', 'att2', 'att2' );
$xmlnode->set_always( get_content => 'attribute content' );
$xmlnode->set_always( get_type_nodetype => 'anodetype,nodetype' );
- $xmlnode->set_series( get_type => 'literal_value', 'noderef' );
+ $xmlnode->set_series( get_type => 'literal_value', 'literal_value', 'noderef', 'noderef' );
- $node->{'attribute name'} = 'attribute content';
+ $node->set_always(get_attribute_name => 'attribute content');
$node->{'att2'} = 123;
+ $node->set_always('get_att2' => 123);
+ $node->mock( selectGroupArray => sub { die } );
+
my $rv = $instance->verify_node( $xmlnode, $node );
is( $rv, undef, '...if the same returns nothing.' );
-
-
- $xmlnode->set_series( get_name => 'attribute name', 'att2' );
+ $xmlnode->set_series( get_name => 'attribute_name', 'attribute_name', 'att2', 'att2', 'att2', 'att2' );
$xmlnode->set_series( get_type => 'literal_value', 'noderef' );
- $node->{'attribute name'} = 'different content';
- $node->{'att2'} = 456;
+ $node->set_always('get_attribute_name' => 'different content');
+ $node->set_always('get_att2' => 456);
+ $mock->set_always( get_title => 'anodetitle' );
+ $mock->set_always( get_type => $mock);
+
+ my @ids = ( 123, 456 );
+ $mock->mock( get_node_id => sub { shift @ids } );
$rv = $instance->verify_node( $xmlnode, $node );
- is_deeply(
- $rv->{attributes},
- {
- 'attribute name' =>
- [
- $xmlnode,
- $node,
- 'literal_value'
- ],
- 'att2' =>
- [
- $xmlnode,
- $node,
- 'noderef',
- $mock
- ]
+ my @diff = sort { $b->get_name cmp $a->get_name } @$rv;
- },
- '...returns a hash ref explaining differences if doesn\'t match.'
- );
+ ok (! $diff[0]->is_noderef, '...is a literal value.');
+ is( $diff[0]->get_nb_node_content, 'different content', '...returns content from nodebase' );
+ is( $diff[0]->get_xmlnode_content, 'attribute content', '...returns content from nodeball.' );
+ ok ( $diff[1]->is_noderef, '...returns a node reference.');
+
+ is( $diff[1]->get_nb_node_ref_name, 'anodetitle', '...returns node name of reference' );
+ is( $diff[1]->get_xmlnode_ref_name, 'attribute content', '...returns nodename of reference in nodeball.' );
+
+ is( $diff[1]->get_nb_node_ref_type, 'anodetitle', '...returns nodetype of reference in nodebase.' );
+ is( $diff[1]->get_xmlnode_ref_type, 'anodetype', '...returns nodetype of reference in nodeball.' );
+
+
#Now test vars
+
+ @ids = ( 123, 456 );
$node->set_always( getVars => { varname1 => 'varvalue', varname2 => 123 } );
- $xmlnode->set_series( get_name => 'varname1', 'varname2' );
+ $xmlnode->set_series( get_name => 'varname1', 'varname1', 'varname2', 'varname2' );
$xmlnode->set_always( 'get_attributes' => [] );
$xmlnode->set_always( get_vars => [ $xmlnode, $xmlnode] );
$xmlnode->set_always( get_group_members => [] );
@@ -982,61 +984,56 @@
$self->{mock}->{node_id} = 456;
$rv = $instance->verify_node( $xmlnode, $node );
- is_deeply(
- $rv->{vars},
- {
- 'varname1' =>
- [
- $xmlnode,
- $node,
- 'literal_value'
- ],
- 'varname2' =>
- [
- $xmlnode,
- $node,
- 'noderef',
- $mock
- ]
+ @diff = sort { $a->get_name cmp $b->get_name } @$rv;
- },
- '...returns a hash ref explaining var differences if no match.'
- );
+ ok (! $diff[0]->is_noderef, '...is var a literal value.');
+ is( $diff[0]->get_nb_node_content, 'varvalue', '...returns var content from nodebase' );
+ is( $diff[0]->get_xmlnode_content, 'attribute content', '...returns var content from nodeball.' );
+ ok ( $diff[1]->is_noderef, '...returns a node reference.');
+
+ is( $diff[1]->get_nb_node_ref_name, 'anodetitle', '...returns node name of reference from var' );
+ is( $diff[1]->get_xmlnode_ref_name, 'attribute content', '...returns nodename of reference in nodeball from var.' );
+
+ is( $diff[1]->get_nb_node_ref_type, 'anodetitle', '...returns nodetype of reference in nodebase from var.' );
+ is( $diff[1]->get_xmlnode_ref_type, 'anodetype', '...returns nodetype of reference in nodeball var.' );
+
#Now test group members
- $node->set_always( selectGroupArray => [ 1, 2 ] );
$xmlnode->set_series( get_name => 'member1', 'member2' );
$xmlnode->set_always( 'get_attributes' => [] );
$xmlnode->set_always( get_vars => [] );
$xmlnode->set_always( get_group_members => [ $xmlnode, $xmlnode ] );
$xmlnode->set_series( get_type => 'literal_value', 'noderef' );
- $self->{mock}->{title} = "Title of a node retrieved from db.";
- $self->{mock}->{node_id} = 123;
+ $node->set_always( selectGroupArray => [ 1, 2 ] );
+ $node->set_always( get_type => $node );
+ $node->set_always( get_node_id => 1);
+ $node->set_always( get_title => 'The node title');
+ $mock->set_always( get_title => "dbnode");
+ $mock->set_always( get_type => $mock );
+ $mock->set_always( get_node_id => 123 );
+
$rv = $instance->verify_node( $xmlnode, $node );
+ my ( $diff ) = @$rv;
is_deeply(
- $rv->{groupmembers},
- {
- 'member1,anodetype' =>
- [
- $xmlnode,
- $node,
- $mock
- ],
-
- 'member2,anodetype' =>
- [
- $xmlnode,
- $node,
- $mock
- ]
-
+ $diff->get_xmlnode_additional,
+ [ {
+ name => 'member1',
+ type => 'anodetype'
},
- '...returns a hash ref explaining var differences if no match.'
+ {
+ name => 'member2',
+ type => 'anodetype'
+ }
+ ]
+ ,
+ '...returns an array ref of hash refs with name & type keys.'
);
+ my $nodes = $diff->get_nb_node_additional;
+ is ( $$nodes[0]->get_title . $$nodes[0]->get_type->get_title, 'dbnodedbnode', '...returns nodes not in nodeball.');
}
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
