projects / scpubgit/DKit.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw
mostly fix "not" stuff
[scpubgit/DKit.git] / t / dot_ssh.t
diff --git a/t/dot_ssh.t b/t/dot_ssh.t
index 6e0a1c6..6557838 100644 (file)
--- a/t/dot_ssh.t
+++ b/t/dot_ssh.t
@@ -4,6 +4,7 @@ use DX::Solver;
 use DX::SetOver;
 use DX::Observer::FromCode;
 use DX::Action::FromCode;
+use File::Spec;
 use Test::Exception;
 
 {
@@ -11,6 +12,8 @@ use Test::Exception;
 
   use Moo;
 
+  with 'DX::Role::Fact';
+
   has path => (is => 'ro', required => 1);
   has info => (is => 'ro', predicate => 1);
 
@@ -18,6 +21,8 @@ use Test::Exception;
 
   use Moo;
 
+  with 'DX::Role::Fact';
+
   has is_directory => (is => 'ro', default => 0);
   has is_file => (is => 'ro', default => 0);
   has mode => (is => 'ro', required => 1);
@@ -39,6 +44,9 @@ my %protos = (
 my %empty = (
   '.ssh' => My::PathStatus->new(
     path => '.ssh'
+  ),
+  '.ssh/authorized_keys' => My::PathStatus->new(
+    path => '.ssh/authorized_keys'
   )
 );
 
@@ -57,9 +65,8 @@ $solver->add_rule(@$_) for (
   [ path => [ qw(PS P) ],
     [ prop => 'PS', \'path', 'P' ] ],
   [ info_prop => [ qw(PS N V) ],
-    [ exists => [ qw(PSI) ],
-      [ prop => 'PS', \'info', 'PSI' ],
-      [ prop => 'PSI', 'N', 'V' ] ] ],
+    [ prop => 'PS', \'info', 'PSI' ],
+    [ prop => 'PSI', 'N', 'V' ] ],
   [ mode => [ qw(PS M) ],
     [ info_prop => 'PS', \'mode', 'M' ] ],
   [ exists_path => [ qw(PS) ],
@@ -75,8 +82,8 @@ $solver->add_rule(@$_) for (
 %path_status = %protos;
 
 sub paths_for_simple {
-  join ' ', map $_->{PS}->bound_value->path, $solver->query(
-    [ qw(PS) ], [ path_status => 'PS' ], @_
+  join ' ', map $_->value_for('PS')->path, $solver->solve(
+    [ path_status => 'PS' ], @_
   )->results;
 }
 
@@ -86,7 +93,7 @@ is(paths_for_simple([ is_directory => 'PS' ]), '.ssh');
 
 is(paths_for_simple([ is_file => 'PS' ]), '.ssh/authorized_keys');
 
-is(paths_for_simple([ mode => 'PS', [ value => '0755' ] ]), '.ssh');
+is(paths_for_simple([ mode => 'PS', \'0755' ]), '.ssh');
 
 $solver->add_rule(
   path_status_at => [ 'PS', 'P' ],
@@ -99,9 +106,8 @@ $solver->add_rule(
 );
 
 throws_ok {
-  $solver->query(
-    [ qw(PS) ],
-      [ path_status_at => 'PS', [ value => '.ssh' ] ]
+  $solver->solve(
+    [ path_status_at => 'PS', \'.ssh' ]
   )->results
 } qr/ARGH/;
 
@@ -121,13 +127,12 @@ $solver->add_rule(
 my @res;
 
 lives_ok {
-  @res = $solver->query(
-    [ qw(PS) ],
-      [ path_status_at => 'PS', [ value => '.ssh' ] ]
+  @res = $solver->solve(
+    [ path_status_at => 'PS', \'.ssh' ]
   )->results
 };
 
-is(join(' ', map $_->{PS}->bound_value->path, @res), '.ssh');
+is(join(' ', map $_->value_for('PS')->path, @res), '.ssh');
 
 delete $solver->rule_set->rules->{'path_status_at/2'};
 
@@ -159,22 +164,22 @@ $solver->add_rule(
 $ob_res{'.ssh'} = $protos{'.ssh'};
 
 sub paths_for {
-  join ' ', map $_->{PS}->bound_value->path, $solver->query([ 'PS' ], @_)->results;
+  join ' ', map $_->value_for('PS')->path, $solver->solve(@_)->results;
 }
 
 is(
-  paths_for([ path_status => 'PS' ], [ path => 'PS', [ value => '.ssh' ] ]),
+  paths_for([ path_status => 'PS' ], [ path => 'PS', \'.ssh' ]),
   '',
   'no .ssh entry'
 );
 
-throws_ok { paths_for([ path_status_at => 'PS', [ value => '.ssh' ] ]) }
+throws_ok { paths_for([ path_status_at => 'PS', \'.ssh' ]) }
   qr/refused/;
 
 $solver->{observation_policy} = sub { 1 };
 
 is(
-  paths_for([ path_status_at => 'PS', [ value => '.ssh' ] ]),
+  paths_for([ path_status_at => 'PS', \'.ssh' ]),
   '.ssh',
   'observation'
 );
@@ -183,13 +188,13 @@ is($path_status{'.ssh'}, $ob_res{'.ssh'});
 
 delete $solver->{observation_policy};
 
-lives_ok { paths_for([ path_status_at => 'PS', [ value => '.ssh' ] ]) }
+lives_ok { paths_for([ path_status_at => 'PS', \'.ssh' ]) }
   'No observation required anymore';
 
 $path_status{'.ssh/authorized_keys'} = $protos{'.ssh/authorized_keys'};
 
 is(
-  paths_for([ path_status => 'PS' ], [ not => [ is_directory => 'PS' ] ]),
+  paths_for([ path_status => 'PS' ], [ not => [ [ is_directory => 'PS' ] ] ]),
   '.ssh/authorized_keys',
   'Negation'
 );
@@ -198,6 +203,9 @@ $solver->add_rule(@$_) for (
   [ directory_at => [ qw(PS P) ],
     [ path_status_at => qw(PS P) ],
     [ is_directory => 'PS' ] ],
+  [ file_at => [ qw(PS P) ],
+    [ path_status_at => qw(PS P) ],
+    [ is_file => 'PS' ] ],
 );
 
 %path_status = ();
@@ -209,7 +217,7 @@ $ob_res{'.ssh'} = $empty{'.ssh'};
 $solver->{observation_policy} = sub { 1 };
 
 sub dot_ssh_query {
-  $solver->query([ 'PS' ], [ directory_at => 'PS' => [ value => '.ssh' ] ]);
+  $solver->solve([ directory_at => 'PS' => \'.ssh' ]);
 }
 
 is_deeply(
@@ -217,18 +225,17 @@ is_deeply(
   []
 );
 
-#::Dwarn(paths_for([ directory_at => 'PS', [ value => '.ssh' ] ]));
+#::Dwarn(paths_for([ directory_at => 'PS', \'.ssh' ]));
 
 $solver->add_rule(@$_) for (
   [ is_directory => [ qw(PS) ],
-    [ not => [ exists_path => 'PS' ] ],
+    [ not => [ [ exists_path => 'PS' ] ] ],
     [ act => [ 'PS' ],
         sub {
-          my ($ps_var) = @_;
-          my ($id, $value) = ($ps_var->id, $ps_var->bound_value);
+          my ($value) = @_;
           DX::Action::FromCode->new(
             expect => sub {
-              ($id => My::PathStatus->new(
+              (path_status => My::PathStatus->new(
                 path => $value->path,
                 info => My::PathStatusInfo->new(
                   is_directory => 1, mode => ''
@@ -251,11 +258,11 @@ is(scalar(@res),1,'Single result');
 
 is($path_status{'.ssh'}, $empty{'.ssh'}, 'Empty observed');
 
-ok(my $action = $res[0]->{PS}->action);
-
-my ($type, $value) = $action->run;
+is(
+  scalar(my ($action) = $res[0]->actions), 1
+);
 
-$solver->facts->{$type}->remove_value($value);
+$solver->run_action($action);
 
 ok(!$path_status{'.ssh'}, 'Empty retracted');
 
@@ -265,6 +272,80 @@ is(scalar(@res),1,'Single result');
 
 is($path_status{'.ssh'}, $protos{'.ssh'}, 'Created observed');
 
-ok(!$res[0]->{PS}->action, 'No action');
+ok(!$res[0]->actions, 'No action');
+
+$solver->add_predicate(
+  catfile => [ qw(DirPath FileName FilePath) ],
+    [ qw(+ + -) ] => sub {
+      +(FilePath => [ value => File::Spec->catfile($_{DirPath}, $_{FileName}) ])
+    },
+);
+
+$solver->add_rule(@$_) for (
+  [ file_in => [ qw(DirStatus FileName FileStatus) ],
+    [ is_directory => qw(DirStatus) ],
+    [ path => qw(DirStatus DirPath) ],
+    [ catfile => qw(DirPath FileName FilePath) ],
+    [ file_at => qw(FileStatus FilePath) ] ],
+  [ is_file => [ qw(PS) ],
+    [ not => [ [ exists_path => 'PS' ] ] ],
+    [ act => [ 'PS' ],
+        sub {
+          my ($value) = @_;
+          DX::Action::FromCode->new(
+            expect => sub {
+              (path_status => My::PathStatus->new(
+                path => $value->path,
+                info => My::PathStatusInfo->new(
+                  is_file => 1, mode => ''
+                )
+              ))
+            },
+            perform => sub {
+              $ob_res{$value->path} = $protos{$value->path};
+              (path_status => $value);
+            }
+          )
+        } ] ]
+);
+
+%path_status = ();
+%ob_res = %empty;
+
+sub keys_file {
+  $solver->solve(
+     [ directory_at => 'D' => \'.ssh' ],
+     [ file_in => 'D' => \'authorized_keys' => 'F' ],
+   );
+}
+
+@res = keys_file()->results;
+
+is(scalar @res, 1, 'One result');
+
+is(scalar(my @act = $res[0]->actions), 2, 'Two actions');
+
+#::Dwarn(\@act);
+
+is(scalar(my ($poss) = grep !@{$_->dependencies}, @act), 1, 'One possible');
+
+$solver->run_action($poss);
+
+@res = keys_file()->results;
+
+is(scalar @res, 1, 'One result');
+
+is(
+  scalar(($poss) = grep !@{$_->dependencies}, $res[0]->actions), 1,
+  'One possible'
+);
+
+$solver->run_action($poss);
+
+@res = keys_file()->results;
+
+is(scalar @res, 1, 'One result');
+
+is(scalar($res[0]->actions), 0, 'No actions');
 
 done_testing;
Unnamed repository; edit this file 'description' to name the repository.