Subversion Repositories zfs_utils

#! /usr/bin/env perl

# Test script for ZFS_Utils module
# if run with no parameters, wil do smoke tests of functions (dry-run safe)
# if run with 2 or more parameters, will read snapshot files and process them
# Usage:
#   perl test_zfs_utils.pl source_snapshots.txt target_snapshots.txt [dataset_name]
#     - source_snapshots.txt: file containing list of source snapshots (one per line)
#     - target_snapshots.txt: file containing list of target snapshots (one per line)
#     - dataset_name: (optional) dataset name to process; if not provided, will
#                     attempt to auto-detect from snapshot names

use strict;
use warnings;
use FindBin;
use lib "$FindBin::Bin";
use lib "$FindBin::Bin/.."; # ensure module path

use ZFS_Utils qw(runCmd loadConfig logMsg makeReplicateCommands $logFileName $displayLogsOnConsole);

# Test script for ZFS_Utils (dry-run safe)

$displayLogsOnConsole = 1;
$logFileName = '/tmp/zfs_utils_test.log';
unlink $logFileName if -f $logFileName;

# Check for command line arguments (source and target snapshot files, and optional dataset)
if (@ARGV >= 2) {
  my ($source_file, $target_file, $dataset_filter) = @ARGV;
  
  print "Reading snapshot files from command line:\n";
  print "  Source: $source_file\n";
  print "  Target: $target_file\n";
  print "  Dataset filter: " . ($dataset_filter || "(auto-detect)") . "\n";
  
  # Read source snapshots (all snapshots on source dataset)
  open my $src_fh, '<', $source_file or die "Cannot open source file '$source_file': $!";
  my @source_snaps = <$src_fh>;
  chomp @source_snaps;
  close $src_fh;
  
  # Read target snapshots (status - snapshots already on target)
  open my $tgt_fh, '<', $target_file or die "Cannot open target file '$target_file': $!";
  my @target_snaps = <$tgt_fh>;
  chomp @target_snaps;
  close $tgt_fh;
  
  print "\nSource snapshots (" . scalar(@source_snaps) . " entries):\n";
  if (@source_snaps) {
    my $end = @source_snaps > 5 ? 4 : $#source_snaps;
    print "  $_\n" for @source_snaps[0..$end];
    print "  ...\n" if @source_snaps > 5;
  }
  
  print "\nTarget snapshots (" . scalar(@target_snaps) . " entries):\n";
  if (@target_snaps) {
    my $end = @target_snaps > 5 ? 4 : $#target_snaps;
    print "  $_\n" for @target_snaps[0..$end];
    print "  ...\n" if @target_snaps > 5;
  }
  
  # Determine dataset to process and extract parent directories
  my $dataset;
  my $source_parent = '';
  my $target_parent = '';
  
  if ($dataset_filter) {
    # Use explicitly provided dataset
    $dataset = $dataset_filter;
    print "\nUsing provided dataset: $dataset\n";
  } else {
    # Extract dataset name from first source snapshot
    if (@source_snaps && $source_snaps[0] =~ /^([^@]+)@/) {
      my $full_path = $1;
      # Extract just the dataset name (last component)
      $dataset = $full_path;
      $dataset =~ s/.*\///;
      # Extract parent directory if present
      if ($full_path =~ /^(.+)\/[^\/]+$/) {
        $source_parent = $1;
      }
    }
    
    unless ($dataset) {
      die "Error: Could not extract dataset name from source snapshots\n";
    }
    
    print "\nAuto-detected dataset: $dataset\n";
  }
  
  # Extract target parent from first target snapshot if available
  if (@target_snaps && $target_snaps[0] =~ /^([^@]+)@/) {
    my $full_path = $1;
    # Extract parent directory if present
    if ($full_path =~ /^(.+)\/[^\/]+$/) {
      $target_parent = $1;
    }
  }
  
  print "Source parent: " . ($source_parent || "(none)") . "\n";
  print "Target parent: " . ($target_parent || "(none)") . "\n";
  
  # Process with makeReplicateCommands
  my @newstatus;
  my $cmds = makeReplicateCommands(\@source_snaps, \@target_snaps, $dataset, $source_parent, $target_parent, \@newstatus);
  
  print "\nGenerated replicate commands:\n";
  if (ref($cmds) eq 'HASH') {
    for my $fs (sort keys %$cmds) {
      print "  $fs => $cmds->{$fs}\n";
    }
  } elsif (ref($cmds) eq 'ARRAY') {
    print "  (No commands generated - returned empty array)\n";
  } else {
    print "  (Unexpected return type)\n";
  }
  
  print "\nNew status entries (" . scalar(@newstatus) . "):\n";
  print "  $_\n" for @newstatus;
  
  print "\nSnapshot file processing complete.\n";
  exit 0;
}

print "Running ZFS_Utils smoke tests (dry-run safe)\n";

# 1) runCmd in scalar context
my $echo_out = runCmd('printf', 'hello_from_runCmd');
print "runCmd scalar output: [$echo_out]\n";

# 2) runCmd in list context
my @ls = runCmd('printf', "line1\nline2\n");
print "runCmd list output: ". join('|', @ls) ."\n";

# 3) loadConfig using a temporary YAML file
my $tmp_yaml = '/tmp/test_zfs_utils.conf.yaml';
open my $yh, '>', $tmp_yaml or die "Cannot write $tmp_yaml: $!";
print $yh "transport:\n  mount_point: /tmp/mount_point_test\n  dryrun: 1\n";
print $yh "datasets:\n  demo:\n    source: pool\n    target: backup\n";
close $yh;

my $loaded = loadConfig($tmp_yaml, { default_key => 'default_value' });
print "Loaded config keys: ". join(', ', sort keys %$loaded) ."\n";
print "transport.mount_point = " . ($loaded->{transport}{mount_point} // '(undef)') ."\n";

# 4) makeReplicateCommands - sample snapshot lines
my @snaplines = (
  'tank/home@2025-12-01-1d extra',
  'tank/home@2025-12-07-1d extra',
  'tank/data@2025-11-01-7d',
);
my @status = ('tank/home@2025-11-30-1d');
my @newstatus;
my $cmds = makeReplicateCommands(\@snaplines, \@status, 'home', 'tank', 'tank', \@newstatus);
print "Generated replicate commands:\n";
for my $fs (sort keys %$cmds) {
  print "  $fs => $cmds->{$fs}\n";
}
print "New status entries: ". join(', ', @newstatus) ."\n";

# 5) logMsg test
logMsg("Test log entry from test_zfs_utils.pl");
print "Log file written to $logFileName (if enabled).\n";

print "Smoke tests complete.\n";

# Clean up temporary YAML
unlink $tmp_yaml;

1;