Add check for generic_rmOldCameraData test

cmd/generic_listLargeDirs/main_test.go

@@ -3,7 +3,6 @@ package main
 import (
 	"encoding/binary"
 	"encoding/hex"
-	"log"
 	"math/rand"
 	"os"
 	"path/filepath"

cmd/generic_rmOldCameraData/main_test.go

@@ -0,0 +1,189 @@
+package main_test
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strconv"
+	"testing"
+	"time"
+)
+
+const (
+	programName = "generic_rmOldCameraData"
+)
+
+type date struct {
+	cam              string
+	year, month, day int
+}
+
+func now() *date {
+	y, m, d := time.Now().Date()
+	return &date{
+		year:  y,
+		month: int(m),
+		day:   d,
+	}
+}
+
+func (d1 *date) isOlderThan(d2 *date) bool {
+	d11 := time.Date(d1.year, time.Month(d1.month), d1.day, 0, 0, 0, 0, time.Local)
+	d22 := time.Date(d1.year, time.Month(d1.month), d1.day, 0, 0, 0, 0, time.Local)
+	return d11.Before(d22)
+}
+
+func Test(t *testing.T) {
+	var (
+		tmpDir       = filepath.Join(os.TempDir(), programName)
+		dataDir      = filepath.Join(tmpDir, "data")
+		buildPath    = filepath.Join(tmpDir, "build", programName)
+		numberOfCams = 4
+	)
+
+	// Remove previous test folder
+	t.Log("Removing previous test folder")
+	rmRf(tmpDir, t)
+
+	// Build binary
+	t.Log("Building binary")
+	goBuild(filepath.Join(getEnv("GOPATH", t), "src", "github.com", "Miguel-Dorta", "surveillance-cameras", "cmd", programName), buildPath, t)
+
+	// Save list of preserved dates for checking
+	preservedDates := make(map[date]bool, numberOfCams*200*12*31)
+	now := now()
+
+	// Make test data
+	t.Log("Making test data...")
+	for c := 0; c <= numberOfCams; c++ {
+		pathCam := filepath.Join(dataDir, fmt.Sprintf("C%03d", c))
+
+		for y := 1900; y <= 2100; y++ {
+			pathCamYear := filepath.Join(pathCam, strconv.Itoa(y))
+
+			for m := 1; m <= 12; m++ {
+				pathCamYearMonth := filepath.Join(pathCamYear, fmt.Sprintf("%02d", m))
+
+				for d := 1; d <= 31; d++ {
+					pathCamYearMonthDay := filepath.Join(pathCamYearMonth, fmt.Sprintf("%02d", d))
+
+					mkdirP(pathCamYearMonthDay, t)
+					touch(filepath.Join(pathCamYearMonthDay, "testfile"), t)
+
+					dat := &date{cam: fmt.Sprintf("C%03d", c), year: y, month: m, day: d}
+					if now.isOlderThan(dat) {
+						preservedDates[*dat] = false
+					}
+				}
+			}
+		}
+	}
+
+	// Execute it
+	t.Log("Executing binary")
+	cmd := exec.Command(buildPath, "-path", dataDir, "-days", "0")
+	if output, err := cmd.CombinedOutput(); err != nil || len(output) != 0 {
+		t.Fatalf("error found executing binary: %s\nOUTPUT: %s", err, string(output))
+	}
+
+	// Check result
+	t.Log("Checking for correct result (1/2)")
+	// Check that there's not files that should have been deleted
+	if err := filepath.Walk(dataDir, func(path string, _ os.FileInfo, err error) error {
+		// Check error
+		if err != nil {
+			t.Errorf("cannot check path %s: %s", path, err)
+			return nil
+		}
+
+		// Split relative path to its parts
+		parts := filepath.SplitList(path)
+		if len(parts) != 4 {
+			return nil
+		}
+
+		// Convert numeric parts into ints
+		y, err := strconv.Atoi(parts[1])
+		if err != nil {
+			t.Errorf("error parsing year in path %s: %s", path, err)
+			return nil
+		}
+		m, err := strconv.Atoi(parts[2])
+		if err != nil {
+			t.Errorf("error parsing month in path %s: %s", path, err)
+			return nil
+		}
+		d, err := strconv.Atoi(parts[3])
+		if err != nil {
+			t.Errorf("error parsing day in path %s: %s", path, err)
+			return nil
+		}
+
+		// Check if the date was saved in preservedDates, that is, if it should be preserved or not.
+		dat := date{cam: parts[0], year: y, month: m, day: d}
+		if _, ok := preservedDates[dat]; !ok {
+			t.Errorf("path %s was not supposed to be preserved", path)
+			return nil
+		}
+		preservedDates[dat] = true
+		return nil
+	}); err != nil {
+		t.Errorf("error walking tree directory: %s", err)
+	}
+
+	// Check if files that should have been preserved were deleted.
+	t.Log("Checking for correct result (2/2)")
+	for k, v := range preservedDates {
+		if !v {
+			t.Errorf("path %s was not preserved!", filepath.Join(k.cam, strconv.Itoa(k.year), strconv.Itoa(k.month), strconv.Itoa(k.day)))
+		}
+	}
+
+	// Clean up
+	t.Log("Clean up")
+	if err := os.RemoveAll(tmpDir); err != nil {
+		t.Errorf("cannot remove tmp dir %s: %s", tmpDir, err)
+	}
+}
+
+func getEnv(key string, t *testing.T) string {
+	value := os.Getenv(key)
+	if value == "" {
+		t.Fatalf("env variable %s not defined", key)
+	}
+	return value
+}
+
+func rmRf(path string, t *testing.T) {
+	if err := os.RemoveAll(path); err != nil {
+		if !errors.Is(err, os.ErrNotExist) {
+			t.Fatalf("error removing path %s: %s", path, err)
+		}
+	}
+}
+
+func goBuild(src, to string, t *testing.T) {
+	cmd := exec.Command("go", "build", "-o", to, src)
+	if output, err := cmd.CombinedOutput(); err != nil {
+		t.Fatalf("error building binary: %s\n%s", err, string(output))
+	}
+}
+
+func mkdirP(path string, t *testing.T) {
+	if err := os.MkdirAll(path, 0777); err != nil {
+		t.Fatalf("cannot create dir %s: %s", path, err)
+	}
+}
+
+func touch(path string, t *testing.T) {
+	f, err := os.Create(path)
+	if err != nil {
+		t.Fatalf("cannot create file %s: %s", path, err)
+	}
+
+	if err = f.Close(); err != nil {
+		t.Fatalf("cannot close file %s: %s", path, err)
+	}
+}

test/generic_rmOldCameraData.sh

@@ -1,14 +1,17 @@
 #!/bin/bash
 
-TMP_DIR="/tmp/generic_rmOldCameraData"
+PROGRAM_NAME="generic_rmOldCameraData"
+TMP_DIR="/tmp/${PROGRAM_NAME}"
 DATA_DIR="${TMP_DIR}/data"
-BUILD_PATH="${TMP_DIR}/build/generic_rmOldCameraData"
+BUILD_PATH="${TMP_DIR}/build/${PROGRAM_NAME}"
+CHECK_PATH="${TMP_DIR}/build/check"
 
 # Clean previous test
 rm -Rf "$TMP_DIR"
 
-# Build executable
-go build -o "$BUILD_PATH" "${GOPATH}/src/github.com/Miguel-Dorta/surveillance-cameras/cmd/generic_rmOldCameraData"
+# Build executables
+go build -o "$BUILD_PATH" "${GOPATH}/src/github.com/Miguel-Dorta/surveillance-cameras/cmd/${PROGRAM_NAME}"
+go build -o "$CHECK_PATH" "${GOPATH}/src/github.com/Miguel-Dorta/surveillance-cameras/test/${PROGRAM_NAME}_check.go"
 
 # Create testdata
 for (( c = 0; c <= 5; c++ )); do
@@ -20,7 +23,7 @@ for (( c = 0; c <= 5; c++ )); do
         for (( m = 1; m <= 12; m++ )); do
             mPath="${yPath}/$(printf %02d $m)"
 
-            for (( d = 1; d < 31; d++ )); do
+            for (( d = 1; d <= 31; d++ )); do
                 dPath="${mPath}/$(printf %02d $d)"
                 mkdir -p "$dPath"
                 touch "${dPath}/testfile"
@@ -32,5 +35,5 @@ done
 # Execute it
 $BUILD_PATH -path "$DATA_DIR" -days 0
 
-# Output
-echo "Please, check $DATA_DIR"
+# Execute test for checking it
+$CHECK_PATH "$DATA_DIR"

test/generic_rmOldCameraData_check.go

@@ -0,0 +1,150 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"sort"
+	"strconv"
+	"time"
+)
+
+var exitStatus = 0
+
+func main() {
+	if len(os.Args) != 2 {
+		fmt.Printf("Usage:    %s <path>", os.Args[0])
+		os.Exit(1)
+	}
+
+	checkCamera(os.Args[1])
+	os.Exit(exitStatus)
+}
+
+func checkCamera(path string) {
+	expectedCameras := []string{"C000", "C001", "C002", "C003", "C004", "C005"}
+
+	actualCameras, err := ListDir(path)
+	if err != nil {
+		_, _ = fmt.Fprintf(os.Stderr, "error listing path %s: %s\n", path, err)
+		exitStatus = 1
+		return
+	}
+
+	if !EqualsStringSlices(expectedCameras, actualCameras) {
+		_, _ = fmt.Fprintf(os.Stderr, "expected camera list (%+v) is not what was found (%+v) in path %s\n", expectedCameras, actualCameras, path)
+		exitStatus = 1
+		return
+	}
+
+	for _, c := range actualCameras {
+		checkYear(filepath.Join(path, c))
+	}
+}
+
+func checkYear(path string) {
+	now := time.Now()
+
+	expectedYears := make([]string, 0, (2100-now.Year())+1)
+	for y := now.Year(); y <= 2100; y++ {
+		expectedYears = append(expectedYears, strconv.Itoa(y))
+	}
+
+	actualYears, err := ListDir(path)
+	if err != nil {
+		_, _ = fmt.Fprintf(os.Stderr, "error listing path %s: %s\n", path, err)
+		exitStatus = 1
+		return
+	}
+
+	if !EqualsStringSlices(expectedYears, actualYears) {
+		_, _ = fmt.Fprintf(os.Stderr, "expected year list (%+v) is not what was found (%+v) in path %s\n", expectedYears, actualYears, path)
+		exitStatus = 1
+		return
+	}
+
+	for _, y := range actualYears {
+		checkMonth(filepath.Join(path, y), y == strconv.Itoa(now.Year()), now)
+	}
+}
+
+func checkMonth(path string, sameYear bool, now time.Time) {
+	start := 1
+	if sameYear {
+		start = int(now.Month())
+	}
+
+	expectedMonths := make([]string, 0, 12)
+	for i := start; i <= 12; i++ {
+		expectedMonths = append(expectedMonths, fmt.Sprintf("%02d", i))
+	}
+
+	actualMonths, err := ListDir(path)
+	if err != nil {
+		_, _ = fmt.Fprintf(os.Stderr, "error listing path %s: %s\n", path, err)
+		exitStatus = 1
+		return
+	}
+
+	if !EqualsStringSlices(expectedMonths, actualMonths) {
+		_, _ = fmt.Fprintf(os.Stderr, "expected month list (%+v) is not what was found (%+v) in path %s\n", expectedMonths, actualMonths, path)
+		exitStatus = 1
+		return
+	}
+
+	for _, m := range actualMonths {
+		checkDay(filepath.Join(path, m), sameYear && m == strconv.Itoa(int(now.Month())), now)
+	}
+}
+
+func checkDay(path string, sameMonth bool, now time.Time) {
+	start := 1
+	if sameMonth {
+		start = now.Day()
+	}
+
+	expectedDays := make([]string, 0, 31)
+	for i := start; i <= 31; i++ {
+		expectedDays = append(expectedDays, fmt.Sprintf("%02d", i))
+	}
+
+	actualDays, err := ListDir(path)
+	if err != nil {
+		_, _ = fmt.Fprintf(os.Stderr, "error listing path %s: %s\n", path, err)
+		exitStatus = 1
+		return
+	}
+
+	if !EqualsStringSlices(expectedDays, actualDays) {
+		_, _ = fmt.Fprintf(os.Stderr, "expected day list (%+v) is not what was found (%+v) in path %s\n", expectedDays, actualDays, path)
+		exitStatus = 1
+		return
+	}
+}
+
+func ListDir(path string) ([]string, error) {
+	f, err := os.Open(path)
+	if err != nil {
+		return nil, err
+	}
+
+	dirNames, err := f.Readdirnames(-1)
+	if err != nil {
+		return nil, err
+	}
+
+	sort.Strings(dirNames)
+	return dirNames, err
+}
+
+func EqualsStringSlices(s1, s2 []string) bool {
+	if len(s1) != len(s2) {
+		return false
+	}
+	for i := range s1 {
+		if s1[i] != s2[i] {
+			return false
+		}
+	}
+	return true
+}