From 914218c1e8fd0dc11c1caee807bbed0cf26fdaf8 Mon Sep 17 00:00:00 2001
From: Jakub Guzik <jakubmguzik@gmail.com>
Date: Wed, 24 Mar 2021 00:42:42 +0100
Subject: [PATCH] Unification of until filter across list/prune endpoints

Signed-off-by: Jakub Guzik <jakubmguzik@gmail.com>
---
 libpod/image/prune.go            |  9 +-------
 libpod/network/netconflist.go    |  2 +-
 pkg/domain/filters/containers.go |  2 +-
 pkg/util/filters.go              |  4 ++--
 pkg/util/filters_test.go         | 38 +++++++++++++++++++++++++++++++-
 5 files changed, 42 insertions(+), 13 deletions(-)

diff --git a/libpod/image/prune.go b/libpod/image/prune.go
index 1ab785dd2b..7ee3e077e3 100644
--- a/libpod/image/prune.go
+++ b/libpod/image/prune.go
@@ -3,11 +3,9 @@ package image
 import (
 	"context"
 	"strings"
-	"time"
 
 	"github.com/containers/podman/v3/libpod/events"
 	"github.com/containers/podman/v3/pkg/domain/entities/reports"
-	"github.com/containers/podman/v3/pkg/timetype"
 	"github.com/containers/podman/v3/pkg/util"
 	"github.com/containers/storage"
 	"github.com/pkg/errors"
@@ -26,15 +24,10 @@ func generatePruneFilterFuncs(filter, filterValue string) (ImageFilter, error) {
 		}, nil
 
 	case "until":
-		ts, err := timetype.GetTimestamp(filterValue, time.Now())
+		until, err := util.ComputeUntilTimestamp([]string{filterValue})
 		if err != nil {
 			return nil, err
 		}
-		seconds, nanoseconds, err := timetype.ParseTimestamps(ts, 0)
-		if err != nil {
-			return nil, err
-		}
-		until := time.Unix(seconds, nanoseconds)
 		return func(i *Image) bool {
 			if !until.IsZero() && i.Created().After((until)) {
 				return true
diff --git a/libpod/network/netconflist.go b/libpod/network/netconflist.go
index 179620a0de..08816f2bdf 100644
--- a/libpod/network/netconflist.go
+++ b/libpod/network/netconflist.go
@@ -262,7 +262,7 @@ func IfPassesPruneFilter(config *config.Config, netconf *libcni.NetworkConfigLis
 		case "label":
 			return util.MatchLabelFilters(filterValues, GetNetworkLabels(netconf)), nil
 		case "until":
-			until, err := util.ComputeUntilTimestamp(key, filterValues)
+			until, err := util.ComputeUntilTimestamp(filterValues)
 			if err != nil {
 				return false, err
 			}
diff --git a/pkg/domain/filters/containers.go b/pkg/domain/filters/containers.go
index 9cae01dc01..84cf03764b 100644
--- a/pkg/domain/filters/containers.go
+++ b/pkg/domain/filters/containers.go
@@ -165,7 +165,7 @@ func GenerateContainerFilterFuncs(filter string, filterValues []string, r *libpo
 			return false
 		}, nil
 	case "until":
-		until, err := util.ComputeUntilTimestamp(filter, filterValues)
+		until, err := util.ComputeUntilTimestamp(filterValues)
 		if err != nil {
 			return nil, err
 		}
diff --git a/pkg/util/filters.go b/pkg/util/filters.go
index 90daef402d..43bf646f13 100644
--- a/pkg/util/filters.go
+++ b/pkg/util/filters.go
@@ -12,10 +12,10 @@ import (
 )
 
 // ComputeUntilTimestamp extracts until timestamp from filters
-func ComputeUntilTimestamp(filter string, filterValues []string) (time.Time, error) {
+func ComputeUntilTimestamp(filterValues []string) (time.Time, error) {
 	invalid := time.Time{}
 	if len(filterValues) != 1 {
-		return invalid, errors.Errorf("specify exactly one timestamp for %s", filter)
+		return invalid, errors.Errorf("specify exactly one timestamp for until")
 	}
 	ts, err := timetype.GetTimestamp(filterValues[0], time.Now())
 	if err != nil {
diff --git a/pkg/util/filters_test.go b/pkg/util/filters_test.go
index 4771f682b7..47259013ec 100644
--- a/pkg/util/filters_test.go
+++ b/pkg/util/filters_test.go
@@ -1,6 +1,8 @@
 package util
 
-import "testing"
+import (
+	"testing"
+)
 
 func TestMatchLabelFilters(t *testing.T) {
 	testLabels := map[string]string{
@@ -75,3 +77,37 @@ func TestMatchLabelFilters(t *testing.T) {
 		})
 	}
 }
+
+func TestComputeUntilTimestamp(t *testing.T) {
+	tests := []struct {
+		name    string
+		args    []string
+		wantErr bool
+	}{
+		{
+			name:    "Return error when more values in list",
+			args:    []string{"5h", "6s"},
+			wantErr: true,
+		},
+		{
+			name:    "Return error when invalid time",
+			args:    []string{"invalidTime"},
+			wantErr: true,
+		},
+		{
+			name:    "Do not return error when correct time format supplied",
+			args:    []string{"44m"},
+			wantErr: false,
+		},
+	}
+	for _, tt := range tests {
+		tt := tt
+		t.Run(tt.name, func(t *testing.T) {
+			_, err := ComputeUntilTimestamp(tt.args)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("ComputeUntilTimestamp() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+		})
+	}
+}