Api Validation, CalendarTypeQuotaDescriptor, Tests for QUotaPeriod, QuotaBucket
diff --git a/api_test.go b/api_test.go
new file mode 100644
index 0000000..8a83c8f
--- /dev/null
+++ b/api_test.go
@@ -0,0 +1,9 @@
+package apidQuota_test
+
+import (
+ . "github.com/onsi/ginkgo"
+)
+
+var _ = Describe("Api", func() {
+
+})
diff --git a/apidQuota_suite_test.go b/apidQuota_suite_test.go
new file mode 100644
index 0000000..2c0443d
--- /dev/null
+++ b/apidQuota_suite_test.go
@@ -0,0 +1,12 @@
+package apidQuota_test
+
+import (
+ . "github.com/onsi/ginkgo"
+ . "github.com/onsi/gomega"
+ "testing"
+)
+
+func TestApidQuota(t *testing.T) {
+ RegisterFailHandler(Fail)
+ RunSpecs(t, "ApidQuota Suite")
+}
diff --git a/quotaBucket/QuotaDescriptorType.go b/quotaBucket/QuotaDescriptorType.go
deleted file mode 100644
index 3e15c4a..0000000
--- a/quotaBucket/QuotaDescriptorType.go
+++ /dev/null
@@ -1,119 +0,0 @@
-package quotaBucket
-
-import (
- "errors"
- "fmt"
- "strings"
- "time"
-)
-
-const (
- QuotaTypeCalendar = "calendar" // after start time
- QuotaTypeFlexi = "flexi" //after first request
- QuotaTypeRollingWindow = "rollingWindow" // in the past "window" time
-)
-
-type QuotaDescriptorType interface {
- SetCurrentPeriod(bucket *QuotaBucket) error
-}
-
-func GetQuotaTypeHandler(qType string) (QuotaDescriptorType, error) {
- var qDescriptor QuotaDescriptorType
- quotaType := strings.ToLower(strings.TrimSpace(qType))
- switch quotaType {
- case QuotaTypeCalendar:
- qDescriptor = &CanlendarQuotaDescriporType{}
- return qDescriptor, nil
- case QuotaTypeFlexi:
- qDescriptor = &FlexiQuotaDescriptorType{}
- return qDescriptor, nil
- case QuotaTypeRollingWindow:
- qDescriptor = &RollingWindowQuotaDescriptorType{}
- return qDescriptor, nil
- default:
- return nil, errors.New("Ignoring unrecognized quota type in request: " + qType)
-
- }
-}
-
-type CanlendarQuotaDescriporType struct{}
-
-func (c CanlendarQuotaDescriporType) SetCurrentPeriod(qbucket *QuotaBucket) error {
- var err error
- startTime := qbucket.GetStartTime()
- currentPeriod, err := qbucket.GetPeriod()
- if err != nil {
- return err
- }
-
- if startTime.Before(time.Now()) || startTime.Equal(time.Now()) {
- if currentPeriod != nil {
- if currentPeriod.IsCurrentPeriod(qbucket) {
- return nil
- }
- } else {
- if currentPeriod.IsCurrentPeriod(qbucket) {
- return nil
- } else {
- qBucketHandler, err := GetQuotaBucketHandler(qbucket.BucketType)
- if err != nil {
- return errors.New("error getting QuotaBucketType: " + err.Error())
- }
- qBucketHandler.resetCount(qbucket)
- }
- }
- }
-
- var currentStart, currentEnd time.Time
- now := time.Now()
- timeUnit := strings.ToLower(strings.TrimSpace(qbucket.TimeUnit))
- switch timeUnit {
- case TimeUnitSECOND:
- currentStart = time.Date(now.Year(), now.Month(), now.Day(), now.Hour(), now.Minute(), now.Second(), 0, time.UTC)
- secInDuration := time.Duration(int64(qbucket.Interval) * time.Second.Nanoseconds())
- currentEnd = currentStart.Add(secInDuration)
- break
- case TimeUnitMINUTE:
- currentStart = time.Date(now.Year(), now.Month(), now.Day(), now.Hour(), now.Minute(), 0, 0, time.UTC)
- minInDuration := time.Duration(int64(qbucket.Interval) * time.Minute.Nanoseconds())
- currentEnd = currentStart.Add(minInDuration)
- break
- case TimeUnitHOUR:
- currentStart = time.Date(now.Year(), now.Month(), now.Day(), now.Hour(), 0, 0, 0, time.UTC)
- hoursInDuration := time.Duration(int64(qbucket.Interval) * time.Hour.Nanoseconds())
- currentEnd = currentStart.Add(hoursInDuration)
-
- break
- case TimeUnitDAY:
- currentStart = time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, time.UTC)
- currentEnd = currentStart.AddDate(0, 0, 1*qbucket.Interval)
- break
- case TimeUnitWEEK:
- //todo
- //currentStart = time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, time.UTC)
- //currentEnd = currentStart.AddDate(0, 0, 7*qbucket.Interval)
- break
- case TimeUnitMONTH:
- currentStart = time.Date(now.Year(), now.Month(), 0, 0, 0, 0, 0, time.UTC)
- currentEnd = currentStart.AddDate(0, 1*qbucket.Interval, 0)
- break
- }
-
- qbucket.SetPeriod(currentStart, currentEnd)
- fmt.Println("inside calendat set period: ", qbucket.quotaBucketData.Period)
- return nil
-}
-
-type FlexiQuotaDescriptorType struct{}
-
-func (c FlexiQuotaDescriptorType) SetCurrentPeriod(qbucket *QuotaBucket) error {
- //yet to implement
- return nil
-}
-
-type RollingWindowQuotaDescriptorType struct{}
-
-func (c RollingWindowQuotaDescriptorType) SetCurrentPeriod(qbucket *QuotaBucket) error {
- //yet to implement
- return nil
-}
diff --git a/quotaBucket/apiUtil.go b/quotaBucket/apiUtil.go
index c00a879..155a24d 100644
--- a/quotaBucket/apiUtil.go
+++ b/quotaBucket/apiUtil.go
@@ -162,12 +162,13 @@
bucketType = value.(string)
//fmt.Println("bucketType: ", bucketType)
- newQBucket, err := NewQuotaBucket(edgeOrgID, id, interval, timeUnit, quotaType, preciseAtSecondsLevel, quotaPeriod, startTime, maxCount, bucketType)
- if err != nil {
- return errors.New("unable to Unmarshal periodMap to quotaPeriod: " + err.Error())
-
- }
+ newQBucket := NewQuotaBucket(edgeOrgID, id, interval, timeUnit, quotaType, preciseAtSecondsLevel, quotaPeriod, startTime, maxCount, bucketType)
qBucket.quotaBucketData = newQBucket.quotaBucketData
+
+ if err := qBucket.Validate(); err != nil {
+ return errors.New("failed in Validating the quotaBucket: " + err.Error())
+ }
+
return nil
}
diff --git a/quotaBucket/quotaBucket.go b/quotaBucket/quotaBucket.go
index 36c9082..99bc6ba 100644
--- a/quotaBucket/quotaBucket.go
+++ b/quotaBucket/quotaBucket.go
@@ -7,14 +7,41 @@
)
const (
+ //add to acceptedTimeUnitList in init() if case any other new timeUnit is added
TimeUnitSECOND = "second"
TimeUnitMINUTE = "minute"
TimeUnitHOUR = "hour"
TimeUnitDAY = "day"
TimeUnitWEEK = "week"
TimeUnitMONTH = "month"
+
+ //add to acceptedBucketTypeList in init() if case any other new bucketType is added
+ QuotaBucketTypeSynchronous = "synchronous"
+ QuotaBucketTypeAsynchronous = "asynchronous"
+ QuotaBucketTypeNonDistributed = "nonDistributed"
+ //todo: Add other accepted bucketTypes
+
+ //errors
+ InvalidQuotaTimeUnitType = "invalidQuotaTimeUnitType"
+ InvalidQuotaBucketType = "invalidQuotaBucketType"
+ InvalidQuotaPeriod = "invalidQuotaPeriod"
)
+var (
+ acceptedTimeUnitList map[string]bool
+ acceptedBucketTypeList map[string]bool
+)
+
+func init() {
+
+ acceptedTimeUnitList = map[string]bool{TimeUnitSECOND: true,
+ TimeUnitMINUTE: true, TimeUnitHOUR: true,
+ TimeUnitDAY: true, TimeUnitWEEK: true, TimeUnitMONTH: true}
+ acceptedBucketTypeList = map[string]bool{QuotaBucketTypeSynchronous: true,
+ QuotaBucketTypeAsynchronous: true, QuotaBucketTypeNonDistributed: true} //todo: add other accpeted bucketTypes
+
+}
+
type QuotaPeriod struct {
inputStartTime time.Time
startTime time.Time
@@ -31,6 +58,25 @@
endTime: pEndTime,
}
return *period
+}
+
+func (qp *QuotaPeriod) GetPeriodInputStartTime() time.Time {
+ return qp.inputStartTime
+}
+
+func (qp *QuotaPeriod) GetPeriodStartTime() time.Time {
+ return qp.startTime
+}
+
+func (qp *QuotaPeriod) GetPeriodEndTime() time.Time {
+ return qp.endTime
+}
+
+func (qp *QuotaPeriod) Validate() (bool, error) {
+ if qp.startTime.Before(qp.endTime) {
+ return true, nil
+ }
+ return false, errors.New(InvalidQuotaPeriod + " : startTime in the period must be before endTime")
}
@@ -53,10 +99,9 @@
func NewQuotaBucket(edgeOrgID string, id string, interval int,
timeUnit string, quotaType string, preciseAtSecondsLevel bool, period QuotaPeriod,
- startTime int64, maxCount int, bucketType string) (*QuotaBucket, error) {
+ startTime int64, maxCount int, bucketType string) *QuotaBucket {
fromUNIXTime := time.Unix(startTime, 0)
-
quotaBucketDataStruct := "aBucketData{
EdgeOrgID: edgeOrgID,
ID: id,
@@ -74,10 +119,33 @@
quotaBucketData: *quotaBucketDataStruct,
}
- return quotaBucket, nil
+ return quotaBucket
}
+func (q *QuotaBucket) Validate() error {
+ //check if the period is valid
+ period,err := q.GetQuotaBucketPeriod()
+ if err != nil {
+ return err
+ }
+ if ok, err := period.Validate(); !ok {
+ return errors.New("invalid Period: " + err.Error())
+ }
+
+ //check valid quotaTimeUnit
+ if ok := IsValidTimeUnit(q.GetTimeUnit()); !ok {
+ return errors.New(InvalidQuotaTimeUnitType)
+ }
+
+ //check valid quotaBucketType
+ if ok := IsValidQuotaBucketType(q.GetBucketType()); !ok {
+ return errors.New(InvalidQuotaBucketType)
+ }
+
+ return nil
+}
+
func (q *QuotaBucket) GetEdgeOrgID() string {
return q.quotaBucketData.EdgeOrgID
}
@@ -90,6 +158,10 @@
return q.quotaBucketData.Interval
}
+func (q *QuotaBucket) GetTimeUnit() string {
+ return q.quotaBucketData.TimeUnit
+}
+
func (q *QuotaBucket) GetStartTime() time.Time {
return q.quotaBucketData.StartTime
}
@@ -98,6 +170,11 @@
return q.quotaBucketData.QuotaType
}
+func (q *QuotaBucket) GetPreciseAtSecondsLevel() bool {
+ return q.quotaBucketData.PreciseAtSecondsLevel
+}
+
+//Calls setCurrentPeriod if QuotaType is rollingWindow or period.endTime is before now.
func (q *QuotaBucket) GetPeriod() (*QuotaPeriod, error) {
if q.quotaBucketData.QuotaType == QuotaTypeRollingWindow {
qRWType := RollingWindowQuotaDescriptorType{}
@@ -106,9 +183,35 @@
return nil, err
}
}
+
+ period,err := q.GetQuotaBucketPeriod()
+ if err != nil {
+ return nil,err
+ }
+ //setCurrentPeriod if endTime > time.now()
+ if period.endTime.Before(time.Now()) || period.endTime.Equal(time.Now()){
+ if err := q.setCurrentPeriod(); err != nil {
+ return nil, err
+ }
+ }
+
return &q.quotaBucketData.Period, nil
}
+//setCurrentPeriod only for rolling window else just return the value of QuotaPeriod
+func (q *QuotaBucket) GetQuotaBucketPeriod() (*QuotaPeriod,error) {
+ if q.quotaBucketData.QuotaType == QuotaTypeRollingWindow {
+ qRWType := RollingWindowQuotaDescriptorType{}
+ err := qRWType.SetCurrentPeriod(q)
+ if err != nil {
+ return nil, err
+ }
+ }
+ return &q.quotaBucketData.Period,nil
+}
+
+
+
func (q *QuotaBucket) GetMaxCount() int {
return q.quotaBucketData.MaxCount
}
@@ -117,11 +220,12 @@
return q.quotaBucketData.BucketType
}
-func (q *quotaBucketData) SetPeriod(startTime time.Time, endTime time.Time) {
- q.Period = QuotaPeriod{inputStartTime: q.StartTime,
+func (q *QuotaBucket) SetPeriod(startTime time.Time, endTime time.Time) {
+ period := QuotaPeriod{inputStartTime: q.GetStartTime(),
startTime: startTime,
endTime: endTime,
}
+ q.quotaBucketData.Period = period
}
func (q *QuotaBucket) setCurrentPeriod() error {
@@ -136,13 +240,16 @@
func (period *QuotaPeriod) IsCurrentPeriod(qBucket *QuotaBucket) bool {
if qBucket != nil && qBucket.GetBucketType() != "" {
- if qBucket.GetBucketType() == QuotaTypeRollingWindow {
- return (period.inputStartTime.Equal(time.Now()) || period.inputStartTime.Before(time.Now()))
+ if qBucket.GetQuotaType() == QuotaTypeRollingWindow {
+ return (period.inputStartTime.Equal(time.Now()) || period.inputStartTime.Before(time.Now()) )
}
- return ((period.inputStartTime.Equal(time.Now()) || period.inputStartTime.Before(time.Now())) &&
- period.startTime.String() != "" && period.endTime.String() != "" &&
- period.startTime.Before(time.Now()) && period.startTime.Equal(time.Now()) &&
- period.endTime.Before(time.Now()) && period.startTime.Equal(time.Now()))
+
+ return (period.inputStartTime.Equal(time.Now()) || period.inputStartTime.Before(time.Now())) &&
+ period.startTime.String() != "" &&
+ period.endTime.String() != "" &&
+ period.startTime.Before(period.endTime) &&
+ (period.startTime.Equal(time.Now()) || period.startTime.Before(time.Now()))&&
+ (period.endTime.Equal(time.Now()) || period.endTime.After(time.Now()))
}
return false
}
@@ -167,3 +274,17 @@
//todo
return 0, nil
}
+
+func IsValidTimeUnit(timeUnit string) bool {
+ if _, ok := acceptedTimeUnitList[timeUnit]; ok {
+ return true
+ }
+ return false
+}
+
+func IsValidQuotaBucketType(bucketType string) bool {
+ if _, ok := acceptedBucketTypeList[bucketType]; ok {
+ return true
+ }
+ return false
+}
diff --git a/quotaBucket/quotaBucketType.go b/quotaBucket/quotaBucketType.go
index 843846b..1eb051a 100644
--- a/quotaBucket/quotaBucketType.go
+++ b/quotaBucket/quotaBucketType.go
@@ -5,13 +5,6 @@
"strings"
)
-const (
- QuotaBucketTypeSynchronous = "synchronous"
- QuotaBucketTypeAsynchronous = "asynchronous"
- QuotaBucketTypeNonDistributed = "nonDistributed"
- //todo: Add other bucketTypes
-)
-
type QuotaBucketType interface {
resetCount(bucket *QuotaBucket) error
}
diff --git a/quotaBucket/quotaBucketType_test.go b/quotaBucket/quotaBucketType_test.go
new file mode 100644
index 0000000..70ee53d
--- /dev/null
+++ b/quotaBucket/quotaBucketType_test.go
@@ -0,0 +1,9 @@
+package quotaBucket_test
+
+import (
+ . "github.com/onsi/ginkgo"
+)
+
+var _ = Describe("QuotaBucketType", func() {
+
+})
diff --git a/quotaBucket/quotaBucket_suite_test.go b/quotaBucket/quotaBucket_suite_test.go
new file mode 100644
index 0000000..b05019b
--- /dev/null
+++ b/quotaBucket/quotaBucket_suite_test.go
@@ -0,0 +1,22 @@
+package quotaBucket_test
+
+import (
+ . "github.com/onsi/ginkgo"
+ . "github.com/onsi/gomega"
+ "fmt"
+ "testing"
+)
+
+func TestQuotaBucket(t *testing.T) {
+ RegisterFailHandler(Fail)
+ RunSpecs(t, "QuotaBucket Suite")
+}
+
+var _ = BeforeSuite(func() {
+ fmt.Println("before suite")
+
+})
+
+var _ = AfterSuite(func() {
+ fmt.Println("after suite")
+})
diff --git a/quotaBucket/quotaBucket_test.go b/quotaBucket/quotaBucket_test.go
new file mode 100644
index 0000000..df50e82
--- /dev/null
+++ b/quotaBucket/quotaBucket_test.go
@@ -0,0 +1,507 @@
+package quotaBucket_test
+
+import (
+ . "github.com/30x/apidQuota/quotaBucket"
+ . "github.com/onsi/ginkgo"
+ . "github.com/onsi/gomega"
+ "strings"
+ "time"
+)
+
+var _ = Describe("Test QuotaPeriod", func() {
+ It("Valid NewQuotaPeriod", func() {
+ //startTime before endTime
+ period := NewQuotaPeriod(1492324596, 1490047028, 1492725428)
+ isValid, err := period.Validate()
+
+ if !isValid || err != nil {
+ Fail("expected isValid: true and error: nil for NewQuotaPeriod")
+ }
+ })
+
+ It("Invalid NewQuotaPeriod", func() {
+ //startTime after endTime
+ period := NewQuotaPeriod(1492324596, 1492725428, 1490047028)
+ isValid, err := period.Validate()
+ if err == nil || isValid {
+ Fail("Expected isValid: false and error: <notNil> for invalid NewQuotaPeriod. startTime should be before endTime")
+ }
+ })
+
+})
+
+var _ = Describe("Test AcceptedQuotaTimeUnitTypes", func() {
+ It("testTimeUnit", func() {
+ if !IsValidTimeUnit("second") {
+ Fail("second is a valid TimeUnit")
+ }
+ if !IsValidTimeUnit("minute") {
+ Fail("minute is a valid TimeUnit")
+ }
+ if !IsValidTimeUnit("hour") {
+ Fail("hour is a valid TimeUnit")
+ }
+ if !IsValidTimeUnit("day") {
+ Fail("day is a valid TimeUnit")
+ }
+ if !IsValidTimeUnit("week") {
+ Fail("week is a valid TimeUnit")
+ }
+ if !IsValidTimeUnit("month") {
+ Fail("month is a valid TimeUnit")
+ }
+
+ //invalid type
+ if IsValidTimeUnit("invalidType") {
+ Fail("invalidType is a invalid TimeUnit")
+ }
+ })
+})
+
+var _ = Describe("Test AcceptedQuotaBucketTypes", func() {
+ It("testTimeUnit", func() {
+ if !IsValidQuotaBucketType("synchronous") {
+ Fail("synchronous is a valid quotaBucket")
+ }
+ if !IsValidQuotaBucketType("asynchronous") {
+ Fail("asynchronous is a valid quotaBucket")
+ }
+ if !IsValidQuotaBucketType("nonDistributed") {
+ Fail("nonDistributed is a valid quotaBucket")
+ }
+
+ //invalid type
+ if IsValidQuotaBucketType("invalidType") {
+ Fail("invalidType is a invalid quotaBucket")
+ }
+ })
+})
+
+var _ = Describe("QuotaBucket", func() {
+ It("Create with NewQuotaBucket", func() {
+ edgeOrgID := "sampleOrg"
+ id := "sampleID"
+ timeUnit := "hour"
+ quotaType := "calendar"
+ bucketType := "synchronous"
+ interval := 1
+ maxCount := 10
+ preciseAtSecondsLevel := true
+ period := NewQuotaPeriod(time.Now().AddDate(0,-1,0).Unix(),
+ time.Now().AddDate(0,0,-1).Unix(),
+ time.Now().AddDate(0,1,0).Unix())
+ startTime := int64(1492324596)
+
+ quotaBucket := NewQuotaBucket(edgeOrgID, id, interval, timeUnit, quotaType, preciseAtSecondsLevel, period, startTime, maxCount, bucketType)
+ err := quotaBucket.Validate()
+ Expect(err).NotTo(HaveOccurred())
+
+
+ //also check if all the fields are set as expected
+ sTime := time.Unix(startTime, 0)
+ Expect(sTime).To(Equal(quotaBucket.GetStartTime()))
+ Expect(edgeOrgID).To(Equal(quotaBucket.GetEdgeOrgID()))
+ Expect(id).To(Equal(quotaBucket.GetID()))
+ Expect(timeUnit).To(Equal(quotaBucket.GetTimeUnit()))
+ Expect(quotaType).To(Equal(quotaBucket.GetQuotaType()))
+ Expect(bucketType).To(Equal(quotaBucket.GetBucketType()))
+ Expect(interval).To(Equal(quotaBucket.GetInterval()))
+ Expect(maxCount).To(Equal(quotaBucket.GetMaxCount()))
+ Expect(preciseAtSecondsLevel).To(Equal(quotaBucket.GetPreciseAtSecondsLevel()))
+ getPeriod, err := quotaBucket.GetPeriod()
+ Expect(err).NotTo(HaveOccurred())
+ Expect(period).To(Equal(*getPeriod))
+
+ })
+
+ It("Test invalid quotaPeriod", func() {
+ edgeOrgID := "sampleOrg"
+ id := "sampleID"
+ timeUnit := "hour"
+ quotaType := "calendar"
+ bucketType := "synchronous"
+ interval := 1
+ maxCount := 10
+ preciseAtSecondsLevel := true
+ period := NewQuotaPeriod(1492324596, 1492725428, 1490047028)
+ startTime := int64(1492324596)
+
+ quotaBucket := NewQuotaBucket(edgeOrgID, id, interval, timeUnit, quotaType, preciseAtSecondsLevel, period, startTime, maxCount, bucketType)
+ err := quotaBucket.Validate()
+ if err == nil {
+ Fail("error expected but got <nil>")
+ }
+ if !strings.Contains(err.Error(), InvalidQuotaPeriod) {
+ Fail("expected: " + InvalidQuotaPeriod + " in the error but got: " + err.Error())
+ }
+
+ })
+
+ It("Test invalid timeUnitType", func() {
+ edgeOrgID := "sampleOrg"
+ id := "sampleID"
+ timeUnit := "invalidTimeUnit"
+ quotaType := "calendar"
+ bucketType := "synchronous"
+ interval := 1
+ maxCount := 10
+ preciseAtSecondsLevel := true
+ period := NewQuotaPeriod(time.Now().AddDate(0,-1,0).Unix(),
+ time.Now().AddDate(0,0,-1).Unix(),
+ time.Now().AddDate(0,1,0).Unix())
+ startTime := int64(1492324596)
+
+ quotaBucket := NewQuotaBucket(edgeOrgID, id, interval, timeUnit, quotaType, preciseAtSecondsLevel, period, startTime, maxCount, bucketType)
+ err := quotaBucket.Validate()
+ if err == nil {
+ Fail("error expected but got <nil>")
+ }
+ if err.Error() != InvalidQuotaTimeUnitType {
+ Fail("expected: " + InvalidQuotaBucketType + "but got: " + err.Error())
+ }
+
+ })
+
+ It("Test invalid quotaBucketType", func() {
+ edgeOrgID := "sampleOrg"
+ id := "sampleID"
+ timeUnit := "hour"
+ quotaType := "calendar"
+ bucketType := "invalidQuotaBucket"
+ interval := 1
+ maxCount := 10
+ preciseAtSecondsLevel := true
+ period := NewQuotaPeriod(time.Now().AddDate(0,-1,0).Unix(),
+ time.Now().AddDate(0,0,-1).Unix(),
+ time.Now().AddDate(0,1,0).Unix())
+ startTime := time.Now().AddDate(0,-1,0).Unix()
+
+ quotaBucket := NewQuotaBucket(edgeOrgID, id, interval, timeUnit, quotaType, preciseAtSecondsLevel, period, startTime, maxCount, bucketType)
+ err := quotaBucket.Validate()
+ if err == nil {
+ Fail("error expected but got <nil>")
+ }
+ if err.Error() != InvalidQuotaBucketType {
+ Fail("expected: " + InvalidQuotaBucketType + "but got: " + err.Error())
+ }
+
+ })
+
+})
+
+
+
+
+var _ = Describe("IsCurrentPeriod", func(){
+ It("Test RollingType Window Valid TestCase", func() {
+
+ edgeOrgID := "sampleOrg"
+ id := "sampleID"
+ timeUnit := "hour"
+ quotaType := "rollingwindow"
+ bucketType := "synchronous"
+ interval := 1
+ maxCount := 10
+ preciseAtSecondsLevel := true
+ //InputStart time is before now
+ period := NewQuotaPeriod(time.Now().AddDate(0, -1,0).Unix(),
+ time.Now().AddDate(0,0, -1).Unix(),
+ time.Now().AddDate(0,1,0).Unix())
+ startTime := time.Now().AddDate(0,-1,0).Unix()
+
+ quotaBucket := NewQuotaBucket(edgeOrgID, id, interval, timeUnit, quotaType, preciseAtSecondsLevel, period, startTime, maxCount, bucketType)
+ err := quotaBucket.Validate()
+ Expect(err).NotTo(HaveOccurred())
+ if ok := period.IsCurrentPeriod(quotaBucket); !ok{
+ Fail("Exprected true, returned: false")
+ }
+
+ //InputStart time is now
+ period = NewQuotaPeriod(time.Now().Unix(),
+ time.Now().AddDate(0,0,-1).Unix(),
+ time.Now().AddDate(0,1,0).Unix())
+ startTime = time.Now().Unix()
+ quotaBucket = NewQuotaBucket(edgeOrgID, id, interval, timeUnit, quotaType, preciseAtSecondsLevel, period, startTime, maxCount, bucketType)
+ err = quotaBucket.Validate()
+ Expect(err).NotTo(HaveOccurred())
+
+
+ period.IsCurrentPeriod(quotaBucket)
+ if ok := period.IsCurrentPeriod(quotaBucket); !ok{
+ Fail("Exprected true, returned: false")
+ }
+ })
+
+ It("Test RollingType Window InValid TestCase", func() {
+
+ edgeOrgID := "sampleOrg"
+ id := "sampleID"
+ timeUnit := "hour"
+ quotaType := "rollingwindow"
+ bucketType := "synchronous"
+ interval := 1
+ maxCount := 10
+ preciseAtSecondsLevel := true
+ //InputStart time is after now.
+ period := NewQuotaPeriod(time.Now().AddDate(0,1,0).Unix(),
+ time.Now().AddDate(0,1,0).Unix(), time.Now().AddDate(0,0,1).Unix())
+ startTime := time.Now().AddDate(0,1,0).Unix()
+
+ quotaBucket := NewQuotaBucket(edgeOrgID, id, interval, timeUnit, quotaType, preciseAtSecondsLevel, period, startTime, maxCount, bucketType)
+ err := quotaBucket.Validate()
+ Expect(err).NotTo(HaveOccurred())
+
+
+ if ok := period.IsCurrentPeriod(quotaBucket); ok{
+ Fail("Exprected true, returned: false")
+ }
+
+ //endTime before startTime in period
+ startTime = time.Now().AddDate(0,-1,0).Unix()
+ quotaBucket = NewQuotaBucket(edgeOrgID, id, interval, timeUnit, quotaType, preciseAtSecondsLevel, period, startTime, maxCount, bucketType)
+ quotaBucket.SetPeriod(time.Now(), time.Now().AddDate(0,1,0))
+ if ok := period.IsCurrentPeriod(quotaBucket); ok{
+ Fail("Exprected false, returned: true")
+ }
+ })
+
+
+ It("Test NonRollingType Window Valid TestCases", func() {
+
+ edgeOrgID := "sampleOrg"
+ id := "sampleID"
+ timeUnit := "hour"
+ quotaType := "calendar"
+ bucketType := "synchronous"
+ interval := 1
+ maxCount := 10
+ preciseAtSecondsLevel := true
+
+
+ //InputStart time is before now
+ period := NewQuotaPeriod(time.Now().AddDate(0, -1,0).Unix(),
+ time.Now().AddDate(0,0, -1).Unix(),
+ time.Now().AddDate(0,1,0).Unix())
+ startTime := time.Now().AddDate(0,-1,0).Unix()
+
+ quotaBucket := NewQuotaBucket(edgeOrgID, id, interval, timeUnit, quotaType, preciseAtSecondsLevel, period, startTime, maxCount, bucketType)
+ err := quotaBucket.Validate()
+ Expect(err).NotTo(HaveOccurred())
+
+ if ok := period.IsCurrentPeriod(quotaBucket); !ok{
+ Fail("Exprected true, returned: false")
+ }
+
+
+ //InputStart time is now
+ period = NewQuotaPeriod(time.Now().Unix(),
+ time.Now().AddDate(0,0,-1).Unix(),
+ time.Now().AddDate(0,1,0).Unix())
+ startTime = time.Now().Unix()
+ quotaBucket = NewQuotaBucket(edgeOrgID, id, interval, timeUnit, quotaType, preciseAtSecondsLevel, period, startTime, maxCount, bucketType)
+ err = quotaBucket.Validate()
+ Expect(err).NotTo(HaveOccurred())
+
+ period.IsCurrentPeriod(quotaBucket)
+ if ok := period.IsCurrentPeriod(quotaBucket); !ok{
+ Fail("Exprected true, returned: false")
+ }
+
+ //start Time in period is before now
+ startTime = time.Now().Unix()
+ period = NewQuotaPeriod(time.Now().AddDate(0,-1,0).Unix(),
+ time.Now().AddDate(0,0,-1).Unix(),
+ time.Now().AddDate(0,1,0).Unix())
+ quotaBucket = NewQuotaBucket(edgeOrgID, id, interval, timeUnit, quotaType, preciseAtSecondsLevel, period, startTime, maxCount, bucketType)
+ err = quotaBucket.Validate()
+ Expect(err).NotTo(HaveOccurred())
+
+ period.IsCurrentPeriod(quotaBucket)
+ if ok := period.IsCurrentPeriod(quotaBucket); !ok{
+ Fail("Exprected true, returned: false")
+ }
+
+ //start Time in period is now
+ startTime = time.Now().Unix()
+ period = NewQuotaPeriod(time.Now().AddDate(0,-1,0).Unix(),
+ time.Now().Unix(),
+ time.Now().AddDate(0,1,0).Unix())
+ quotaBucket = NewQuotaBucket(edgeOrgID, id, interval, timeUnit, quotaType, preciseAtSecondsLevel, period, startTime, maxCount, bucketType)
+ err = quotaBucket.Validate()
+ Expect(err).NotTo(HaveOccurred())
+
+ period.IsCurrentPeriod(quotaBucket)
+ if ok := period.IsCurrentPeriod(quotaBucket); !ok{
+ Fail("Exprected true, returned: false")
+ }
+
+ //end Time in period is now // cant set end time to now and tes.. by the time it evaluates isCurrentPeriod the period.endTime will be before time.now()
+ //fmt.Println("entTIme is now : ")
+ //startTime = time.Now().Unix()
+ //period = NewQuotaPeriod(time.Now().AddDate(0,-1,-1).Unix(),
+ // time.Now().AddDate(0,0,-1).Unix(),
+ // time.Now().Unix())
+ //quotaBucket = NewQuotaBucket(edgeOrgID, id, interval, timeUnit, quotaType, preciseAtSecondsLevel, period, startTime, maxCount, bucketType)
+ //err = quotaBucket.Validate()
+ //if err != nil {
+ // Fail("no error expected but got error: " + err.Error())
+ //}
+ //
+ //period.IsCurrentPeriod(quotaBucket)
+ //if ok := period.IsCurrentPeriod(quotaBucket); !ok{
+ // Fail("Exprected true, returned: false")
+ //}
+
+ //end Time in period is after now
+ startTime = time.Now().Unix()
+ period = NewQuotaPeriod(time.Now().AddDate(0,-1,0).Unix(),
+ time.Now().AddDate(0,0,-1).Unix(),
+ time.Now().AddDate(0,1,0).Unix())
+ quotaBucket = NewQuotaBucket(edgeOrgID, id, interval, timeUnit, quotaType, preciseAtSecondsLevel, period, startTime, maxCount, bucketType)
+ err = quotaBucket.Validate()
+ Expect(err).NotTo(HaveOccurred())
+
+ period.IsCurrentPeriod(quotaBucket)
+ if ok := period.IsCurrentPeriod(quotaBucket); !ok{
+ Fail("Exprected true, returned: false")
+ }
+
+ //start time in period is before end time
+ startTime = time.Now().Unix()
+ period = NewQuotaPeriod(time.Now().AddDate(0,-1,0).Unix(),
+ time.Now().AddDate(0,-1,0).Unix(),
+ time.Now().AddDate(0,1,0).Unix())
+ quotaBucket = NewQuotaBucket(edgeOrgID, id, interval, timeUnit, quotaType, preciseAtSecondsLevel, period, startTime, maxCount, bucketType)
+ err = quotaBucket.Validate()
+ Expect(err).NotTo(HaveOccurred())
+
+ period.IsCurrentPeriod(quotaBucket)
+ if ok := period.IsCurrentPeriod(quotaBucket); !ok{
+ Fail("Exprected true, returned: false")
+ }
+
+ })
+
+ It("Test Non RollingType Window InValid TestCase", func() {
+
+ edgeOrgID := "sampleOrg"
+ id := "sampleID"
+ timeUnit := "hour"
+ quotaType := "calendar"
+ bucketType := "synchronous"
+ interval := 1
+ maxCount := 10
+ preciseAtSecondsLevel := true
+
+ //InputStart time is after now.
+ period := NewQuotaPeriod(time.Now().AddDate(0,1,0).Unix(),
+ time.Now().AddDate(0,1,0).Unix(), time.Now().AddDate(1,0,1).Unix())
+ startTime := time.Now().AddDate(0,1,0).Unix()
+
+ quotaBucket := NewQuotaBucket(edgeOrgID, id, interval, timeUnit, quotaType, preciseAtSecondsLevel, period, startTime, maxCount, bucketType)
+ err := quotaBucket.Validate()
+ Expect(err).NotTo(HaveOccurred())
+
+ if ok := period.IsCurrentPeriod(quotaBucket); ok{
+ Fail("Exprected true, returned: false")
+ }
+
+
+ //endTime is before start time
+ startTime = time.Now().AddDate(0,-1,0).Unix()
+ quotaBucket = NewQuotaBucket(edgeOrgID, id, interval, timeUnit, quotaType, preciseAtSecondsLevel, period, startTime, maxCount, bucketType)
+ err = quotaBucket.Validate()
+ Expect(err).NotTo(HaveOccurred())
+
+ quotaBucket.SetPeriod(time.Now(), time.Now().AddDate(0,-1,0))
+
+ if ok := period.IsCurrentPeriod(quotaBucket); ok{
+ Fail("Exprected true, returned: false")
+ }
+
+ //start time in period after now
+ quotaBucket.SetPeriod(time.Now().AddDate(0,1,0), time.Now().AddDate(1,1,0))
+
+ if ok := period.IsCurrentPeriod(quotaBucket); ok{
+ Fail("Exprected true, returned: false")
+ }
+
+ //end time in period is before now
+ quotaBucket.SetPeriod(time.Now().AddDate(-1,-1,0), time.Now().AddDate(0,-1,0))
+
+ if ok := period.IsCurrentPeriod(quotaBucket); ok{
+ Fail("Exprected true, returned: false")
+ }
+
+ })
+})
+
+
+var _ = Describe("Test GetPeriod and setCurrentPeriod", func() {
+ It("Valid GetPeriod", func() {
+ edgeOrgID := "sampleOrg"
+ id := "sampleID"
+ timeUnit := "hour"
+ quotaType := "rollingwindow"
+ bucketType := "synchronous"
+ interval := 1
+ maxCount := 10
+ preciseAtSecondsLevel := true
+ //InputStart time is before now
+ period := NewQuotaPeriod(time.Now().AddDate(0, -1,0).Unix(),
+ time.Now().AddDate(0,0, -1).Unix(),
+ time.Now().AddDate(0,1,0).Unix())
+ startTime := time.Now().AddDate(0,-1,0).Unix()
+ quotaBucket := NewQuotaBucket(edgeOrgID, id, interval, timeUnit, quotaType, preciseAtSecondsLevel, period, startTime, maxCount, bucketType)
+ err := quotaBucket.Validate()
+ Expect(err).NotTo(HaveOccurred())
+ qPeriod, err := quotaBucket.GetPeriod()
+ Expect(err).NotTo(HaveOccurred())
+
+ // check if the rolling window was set properly
+ Expect(qPeriod.GetPeriodInputStartTime()).Should(Equal(quotaBucket.GetStartTime()))
+ if !qPeriod.GetPeriodEndTime().After(qPeriod.GetPeriodStartTime()){
+ Fail("Rolling Window was not set as expected")
+ }
+ intervalDuration := qPeriod.GetPeriodEndTime().Sub(qPeriod.GetPeriodStartTime())
+ expectedDuration, err := GetIntervalDurtation(quotaBucket)
+ Expect(intervalDuration).Should(Equal(expectedDuration))
+
+
+ //for non rolling Type window do not setCurrentPeriod as endTime is > time.now.
+ quotaType = "calendar"
+ pstartTime := time.Now().AddDate(0,-1,0)
+ pendTime := time.Now().AddDate(0,1,0)
+ quotaBucket = NewQuotaBucket(edgeOrgID, id, interval, timeUnit, quotaType, preciseAtSecondsLevel, period, startTime, maxCount, bucketType)
+ quotaBucket.SetPeriod(pstartTime, pendTime)
+ qPeriod, err = quotaBucket.GetPeriod()
+ Expect(err).NotTo(HaveOccurred())
+ // check if the calendar window was set properly
+ Expect(qPeriod.GetPeriodInputStartTime()).Should(Equal(quotaBucket.GetStartTime()))
+ if !qPeriod.GetPeriodEndTime().After(qPeriod.GetPeriodStartTime()){
+ Fail("Rolling Window was not set as expected")
+ }
+
+ //for non rolling Type window setCurrentPeriod as endTime is < time.now.
+ quotaType = "calendar"
+ pstartTime = time.Now().AddDate(0,-1,0)
+ pendTime = time.Now().AddDate(0,-1,0)
+ quotaBucket = NewQuotaBucket(edgeOrgID, id, interval, timeUnit, quotaType, preciseAtSecondsLevel, period, startTime, maxCount, bucketType)
+ quotaBucket.SetPeriod(pstartTime, pendTime)
+ qPeriod, err = quotaBucket.GetPeriod()
+ Expect(err).NotTo(HaveOccurred())
+ // check if the calendar window was set properly
+ Expect(qPeriod.GetPeriodInputStartTime()).Should(Equal(quotaBucket.GetStartTime()))
+ if !qPeriod.GetPeriodEndTime().After(qPeriod.GetPeriodStartTime()){
+ Fail("Rolling Window was not set as expected")
+ }
+ intervalDuration = qPeriod.GetPeriodEndTime().Sub(qPeriod.GetPeriodStartTime())
+ expectedDuration, err = GetIntervalDurtation(quotaBucket)
+ Expect(intervalDuration).Should(Equal(expectedDuration))
+
+
+
+ })
+
+})
+
diff --git a/quotaBucket/quotaDescriptorType.go b/quotaBucket/quotaDescriptorType.go
new file mode 100644
index 0000000..c94333c
--- /dev/null
+++ b/quotaBucket/quotaDescriptorType.go
@@ -0,0 +1,155 @@
+package quotaBucket
+
+import (
+ "errors"
+ "fmt"
+ "strings"
+ "time"
+)
+
+const (
+ QuotaTypeCalendar = "calendar" // after start time
+ QuotaTypeFlexi = "flexi" //after first request
+ QuotaTypeRollingWindow = "rollingwindow" // in the past "window" time
+)
+
+type QuotaDescriptorType interface {
+ SetCurrentPeriod(bucket *QuotaBucket) error
+}
+
+func GetQuotaTypeHandler(qType string) (QuotaDescriptorType, error) {
+ var qDescriptor QuotaDescriptorType
+ quotaType := strings.ToLower(strings.TrimSpace(qType))
+ switch quotaType {
+ case QuotaTypeCalendar:
+ qDescriptor = &CalendarQuotaDescriptorType{}
+ return qDescriptor, nil
+ case QuotaTypeRollingWindow:
+ qDescriptor = &RollingWindowQuotaDescriptorType{}
+ return qDescriptor, nil
+ default:
+ return nil, errors.New("Quota type " + qType + " in the request is not supported")
+
+ }
+}
+
+type CalendarQuotaDescriptorType struct{}
+
+func (c CalendarQuotaDescriptorType) SetCurrentPeriod(qbucket *QuotaBucket) error {
+ startTime := qbucket.GetStartTime()
+ currentPeriod,err := qbucket.GetQuotaBucketPeriod()
+if err != nil {
+ return err
+}
+ if startTime.Before(time.Now()) || startTime.Equal(time.Now()) {
+ if currentPeriod != nil {
+ if currentPeriod.IsCurrentPeriod(qbucket) {
+ return nil
+ }
+ } else {
+ if currentPeriod.IsCurrentPeriod(qbucket) {
+ return nil
+ } else {
+ qBucketHandler, err := GetQuotaBucketHandler(qbucket.BucketType)
+ if err != nil {
+ return errors.New("error getting QuotaBucketType: " + err.Error())
+ }
+ qBucketHandler.resetCount(qbucket)
+ }
+ }
+ }
+
+ var currentStart, currentEnd time.Time
+ now := time.Now()
+ timeUnit := strings.ToLower(strings.TrimSpace(qbucket.TimeUnit))
+ switch timeUnit {
+ case TimeUnitSECOND:
+ currentStart = time.Date(now.Year(), now.Month(), now.Day(), now.Hour(), now.Minute(), now.Second(), 0, time.UTC)
+ secInDuration := time.Duration(int64(qbucket.Interval) * time.Second.Nanoseconds())
+ currentEnd = currentStart.Add(secInDuration)
+ break
+ case TimeUnitMINUTE:
+ currentStart = time.Date(now.Year(), now.Month(), now.Day(), now.Hour(), now.Minute(), 0, 0, time.UTC)
+ minInDuration := time.Duration(int64(qbucket.Interval) * time.Minute.Nanoseconds())
+ currentEnd = currentStart.Add(minInDuration)
+ break
+ case TimeUnitHOUR:
+ currentStart = time.Date(now.Year(), now.Month(), now.Day(), now.Hour(), 0, 0, 0, time.UTC)
+ hoursInDuration := time.Duration(int64(qbucket.Interval) * time.Hour.Nanoseconds())
+ currentEnd = currentStart.Add(hoursInDuration)
+
+ break
+ case TimeUnitDAY:
+ currentStart = time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, time.UTC)
+ currentEnd = currentStart.AddDate(0, 0, 1*qbucket.Interval)
+ break
+ case TimeUnitWEEK:
+ //todo
+ currentStart = time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, time.UTC)
+ for currentStart.Weekday() != time.Monday {
+ currentStart = currentStart.AddDate(0, 0, -1)
+ }
+ currentEnd = currentStart.AddDate(0, 0, 7*qbucket.Interval)
+ break
+ case TimeUnitMONTH:
+ currentStart = time.Date(now.Year(), now.Month(), 0, 0, 0, 0, 0, time.UTC)
+ currentEnd = currentStart.AddDate(0, qbucket.Interval, 0)
+ break
+ }
+
+ qbucket.SetPeriod(currentStart, currentEnd)
+ fmt.Println("inside calendar set period: ", qbucket.quotaBucketData.Period)
+ return nil
+}
+
+type RollingWindowQuotaDescriptorType struct{}
+
+func (c RollingWindowQuotaDescriptorType) SetCurrentPeriod(qbucket *QuotaBucket) error {
+ //yet to implement
+ var currentStart, currentEnd time.Time
+ currentEnd = time.Now()
+ interval, err := GetIntervalDurtation(qbucket)
+ if err != nil {
+ return errors.New("error in SetCurrentPeriod: " + err.Error())
+ }
+ currentStart = currentEnd.Add(-interval)
+ qbucket.SetPeriod(currentStart, currentEnd)
+
+ return nil
+}
+func GetIntervalDurtation(qb *QuotaBucket) (time.Duration, error) {
+ timeUnit := strings.ToLower(strings.TrimSpace(qb.TimeUnit))
+ switch timeUnit {
+ case TimeUnitSECOND:
+ return time.Duration(int64(qb.Interval) * time.Second.Nanoseconds()), nil
+ case TimeUnitMINUTE:
+ return time.Duration(int64(qb.Interval) * time.Minute.Nanoseconds()), nil
+ case TimeUnitHOUR:
+ return time.Duration(int64(qb.Interval) * time.Hour.Nanoseconds()), nil
+ case TimeUnitDAY:
+ return time.Duration(int64(qb.Interval*24) * time.Hour.Nanoseconds()), nil
+ case TimeUnitWEEK:
+ return time.Duration(int64(qb.Interval*24*7) * time.Hour.Nanoseconds()), nil
+ case TimeUnitMONTH:
+ now := time.Now()
+ var currentStart, currentEnd time.Time
+ quotaType := strings.ToLower(strings.TrimSpace(qb.QuotaType))
+ switch quotaType {
+ case QuotaTypeCalendar:
+ currentStart = time.Date(now.Year(), now.Month(), 0, 0, 0, 0, 0, time.UTC)
+ currentEnd = currentStart.AddDate(0, qb.Interval, 0)
+ return currentEnd.Sub(currentStart), nil
+ case QuotaTypeRollingWindow:
+ currentEnd = now
+ currentStart = currentEnd.AddDate(0, -qb.Interval, 0)
+ return currentEnd.Sub(currentStart), nil
+ default:
+ return time.Duration(0), errors.New("Ignoring unrecognized quotaType : " + quotaType)
+
+ }
+ default:
+ return time.Duration(0), errors.New("Ignoring unrecognized timeUnit : " + timeUnit)
+
+ }
+
+}
diff --git a/quotaBucket/quotaDescriptorType_test.go b/quotaBucket/quotaDescriptorType_test.go
new file mode 100644
index 0000000..22a4a08
--- /dev/null
+++ b/quotaBucket/quotaDescriptorType_test.go
@@ -0,0 +1,9 @@
+package quotaBucket_test
+
+import (
+ . "github.com/onsi/ginkgo"
+)
+
+var _ = Describe("QuotaDescriptorType", func() {
+
+})
