From 69a3fc7ba71cd72710c136f182f814193ae87a5b Mon Sep 17 00:00:00 2001 From: Oliver Calder Date: Wed, 24 Apr 2024 13:41:12 -0500 Subject: [PATCH] o/i/apparmorprompting: store expiration as time.Time instead of *time.Time Signed-off-by: Oliver Calder --- interfaces/prompting/prompting.go | 35 +++++++++++++------------- interfaces/prompting/prompting_test.go | 34 ++++++++++++------------- 2 files changed, 33 insertions(+), 36 deletions(-) diff --git a/interfaces/prompting/prompting.go b/interfaces/prompting/prompting.go index 9e06e1ec6b96..d58211d2e140 100644 --- a/interfaces/prompting/prompting.go +++ b/interfaces/prompting/prompting.go @@ -70,20 +70,20 @@ const ( // the given expiration is valid for that lifespan. // // If the lifespan is LifespanTimespan LifespanTimespan, then expiration must -// be non-nil. Otherwise, it must be nil. Returns an error if any of the above -// are invalid. -func ValidateLifespanExpiration(lifespan LifespanType, expiration *time.Time, currTime time.Time) error { +// be non-zero and be after the given currTime. Otherwise, it must be zero. +// Returns an error if any of the above are invalid. +func ValidateLifespanExpiration(lifespan LifespanType, expiration time.Time, currTime time.Time) error { switch lifespan { case LifespanForever, LifespanSession, LifespanSingle: - if expiration != nil { - return fmt.Errorf(`invalid expiration: expiration must be nil when lifespan is %q, but received non-nil expiration: %q`, lifespan, *expiration) + if !expiration.IsZero() { + return fmt.Errorf(`expiration must be omitted when lifespan is %q, but received non-zero expiration: %q`, lifespan, expiration) } case LifespanTimespan: - if expiration == nil { - return fmt.Errorf(`invalid expiration: expiration must be non-nil when lifespan is %q, but received nil expiration`, lifespan) + if expiration.IsZero() { + return fmt.Errorf(`expiration must be non-zero when lifespan is %q, but received empty expiration`, lifespan) } - if currTime.After(*expiration) { - return fmt.Errorf("invalid expiration: expiration time has already passed: %q", *expiration) + if currTime.After(expiration) { + return fmt.Errorf("expiration time has already passed: %q", expiration) } default: return fmt.Errorf(`invalid lifespan: %q`, lifespan) @@ -99,28 +99,27 @@ func ValidateLifespanExpiration(lifespan LifespanType, expiration *time.Time, cu // should be valid. Otherwise, it must be empty. Returns an error if any of the // above are invalid, otherwise computes the expiration time of the rule based // on the current time and the given duration and returns it. -func ValidateLifespanParseDuration(lifespan LifespanType, duration string) (*time.Time, error) { - var expiration *time.Time +func ValidateLifespanParseDuration(lifespan LifespanType, duration string) (time.Time, error) { + var expiration time.Time switch lifespan { case LifespanForever, LifespanSession, LifespanSingle: if duration != "" { - return nil, fmt.Errorf(`invalid duration: duration must be empty when lifespan is %q, but received non-empty duration: %q`, lifespan, duration) + return expiration, fmt.Errorf(`duration must be empty when lifespan is %q, but received non-empty duration: %q`, lifespan, duration) } case LifespanTimespan: if duration == "" { - return nil, fmt.Errorf(`invalid duration: duration must be non-empty when lifespan is %q, but received empty expiration`, lifespan) + return expiration, fmt.Errorf(`duration must be non-empty when lifespan is %q, but received empty expiration`, lifespan) } parsedDuration, err := time.ParseDuration(duration) if err != nil { - return nil, fmt.Errorf(`invalid duration: error parsing duration string: %q`, duration) + return expiration, fmt.Errorf(`error parsing duration string: %q`, duration) } if parsedDuration <= 0 { - return nil, fmt.Errorf(`invalid duration: duration must be greater than zero: %q`, duration) + return expiration, fmt.Errorf(`duration must be greater than zero: %q`, duration) } - expirationValue := time.Now().Add(parsedDuration) - expiration = &expirationValue + expiration = time.Now().Add(parsedDuration) default: - return nil, fmt.Errorf(`invalid lifespan: %q`, lifespan) + return expiration, fmt.Errorf(`invalid lifespan: %q`, lifespan) } return expiration, nil } diff --git a/interfaces/prompting/prompting_test.go b/interfaces/prompting/prompting_test.go index c5567388759f..34c7f9ccf8f5 100644 --- a/interfaces/prompting/prompting_test.go +++ b/interfaces/prompting/prompting_test.go @@ -65,12 +65,10 @@ func (s *promptingSuite) TestValidateOutcome(c *C) { } func (s *promptingSuite) TestValidateLifespanExpiration(c *C) { - var unsetExpiration *time.Time + var unsetExpiration time.Time currTime := time.Now() - negativeExpirationValue := currTime.Add(-5 * time.Second) - negativeExpiration := &negativeExpirationValue - validExpirationValue := currTime.Add(10 * time.Minute) - validExpiration := &validExpirationValue + negativeExpiration := currTime.Add(-5 * time.Second) + validExpiration := currTime.Add(10 * time.Minute) for _, lifespan := range []prompting.LifespanType{ prompting.LifespanForever, @@ -79,17 +77,17 @@ func (s *promptingSuite) TestValidateLifespanExpiration(c *C) { } { err := prompting.ValidateLifespanExpiration(lifespan, unsetExpiration, currTime) c.Check(err, IsNil) - for _, exp := range []*time.Time{negativeExpiration, validExpiration} { + for _, exp := range []time.Time{negativeExpiration, validExpiration} { err = prompting.ValidateLifespanExpiration(lifespan, exp, currTime) - c.Check(err, ErrorMatches, `invalid expiration: expiration must be nil.*`) + c.Check(err, ErrorMatches, `expiration must be omitted.*`) } } err := prompting.ValidateLifespanExpiration(prompting.LifespanTimespan, unsetExpiration, currTime) - c.Check(err, ErrorMatches, `invalid expiration: expiration must be non-nil.*`) + c.Check(err, ErrorMatches, `expiration must be non-zero.*`) err = prompting.ValidateLifespanExpiration(prompting.LifespanTimespan, negativeExpiration, currTime) - c.Check(err, ErrorMatches, `invalid expiration: expiration time has already passed.*`) + c.Check(err, ErrorMatches, `expiration time has already passed.*`) err = prompting.ValidateLifespanExpiration(prompting.LifespanTimespan, validExpiration, currTime) c.Check(err, IsNil) @@ -109,26 +107,26 @@ func (s *promptingSuite) TestValidateLifespanParseDuration(c *C) { prompting.LifespanSingle, } { expiration, err := prompting.ValidateLifespanParseDuration(lifespan, unsetDuration) - c.Check(expiration, IsNil) + c.Check(expiration.IsZero(), Equals, true) c.Check(err, IsNil) for _, dur := range []string{invalidDuration, negativeDuration, validDuration} { expiration, err = prompting.ValidateLifespanParseDuration(lifespan, dur) - c.Check(expiration, IsNil) - c.Check(err, ErrorMatches, `invalid duration: duration must be empty.*`) + c.Check(expiration.IsZero(), Equals, true) + c.Check(err, ErrorMatches, `duration must be empty.*`) } } expiration, err := prompting.ValidateLifespanParseDuration(prompting.LifespanTimespan, unsetDuration) - c.Check(expiration, IsNil) - c.Check(err, ErrorMatches, `invalid duration: duration must be non-empty.*`) + c.Check(expiration.IsZero(), Equals, true) + c.Check(err, ErrorMatches, `duration must be non-empty.*`) expiration, err = prompting.ValidateLifespanParseDuration(prompting.LifespanTimespan, invalidDuration) - c.Check(expiration, IsNil) - c.Check(err, ErrorMatches, `invalid duration: error parsing duration string.*`) + c.Check(expiration.IsZero(), Equals, true) + c.Check(err, ErrorMatches, `error parsing duration string.*`) expiration, err = prompting.ValidateLifespanParseDuration(prompting.LifespanTimespan, negativeDuration) - c.Check(expiration, IsNil) - c.Check(err, ErrorMatches, `invalid duration: duration must be greater than zero.*`) + c.Check(expiration.IsZero(), Equals, true) + c.Check(err, ErrorMatches, `duration must be greater than zero.*`) expiration, err = prompting.ValidateLifespanParseDuration(prompting.LifespanTimespan, validDuration) c.Check(err, IsNil)