mirror of
https://github.com/cgrates/cgrates.git
synced 2026-02-14 12:49:54 +05:00
520 lines
20 KiB
Go
520 lines
20 KiB
Go
/*
|
|
Rating system designed to be used in VoIP Carriers World
|
|
Copyright (C) 2013 ITsysCOM
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>
|
|
*/
|
|
|
|
package engine
|
|
|
|
import (
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func TestRightMargin(t *testing.T) {
|
|
i := &Interval{WeekDays: []time.Weekday{time.Monday, time.Tuesday, time.Wednesday, time.Thursday, time.Friday}}
|
|
t1 := time.Date(2012, time.February, 3, 23, 45, 0, 0, time.UTC)
|
|
t2 := time.Date(2012, time.February, 4, 0, 10, 0, 0, time.UTC)
|
|
ts := &TimeSpan{TimeStart: t1, TimeEnd: t2}
|
|
oldDuration := ts.GetDuration()
|
|
nts := ts.SplitByInterval(i)
|
|
if ts.TimeStart != t1 || ts.TimeEnd != time.Date(2012, time.February, 3, 23, 59, 59, 0, time.UTC) {
|
|
t.Error("Incorrect first half", ts)
|
|
}
|
|
if nts.TimeStart != time.Date(2012, time.February, 3, 23, 59, 59, 0, time.UTC) || nts.TimeEnd != t2 {
|
|
t.Error("Incorrect second half", nts)
|
|
}
|
|
if ts.Interval != i {
|
|
t.Error("Interval not attached correctly")
|
|
}
|
|
|
|
if ts.GetDuration().Seconds() != 15*60-1 || nts.GetDuration().Seconds() != 10*60+1 {
|
|
t.Error("Wrong durations.for Intervals", ts.GetDuration().Seconds(), ts.GetDuration().Seconds())
|
|
}
|
|
|
|
if ts.GetDuration().Seconds()+nts.GetDuration().Seconds() != oldDuration.Seconds() {
|
|
t.Errorf("The duration has changed: %v + %v != %v", ts.GetDuration().Seconds(), nts.GetDuration().Seconds(), oldDuration.Seconds())
|
|
}
|
|
}
|
|
|
|
func TestRightHourMargin(t *testing.T) {
|
|
i := &Interval{WeekDays: []time.Weekday{time.Monday, time.Tuesday, time.Wednesday, time.Thursday, time.Friday}, EndTime: "17:59:00"}
|
|
t1 := time.Date(2012, time.February, 3, 17, 30, 0, 0, time.UTC)
|
|
t2 := time.Date(2012, time.February, 3, 18, 00, 0, 0, time.UTC)
|
|
ts := &TimeSpan{TimeStart: t1, TimeEnd: t2}
|
|
oldDuration := ts.GetDuration()
|
|
nts := ts.SplitByInterval(i)
|
|
if ts.TimeStart != t1 || ts.TimeEnd != time.Date(2012, time.February, 3, 17, 59, 00, 0, time.UTC) {
|
|
t.Error("Incorrect first half", ts)
|
|
}
|
|
if nts.TimeStart != time.Date(2012, time.February, 3, 17, 59, 00, 0, time.UTC) || nts.TimeEnd != t2 {
|
|
t.Error("Incorrect second half", nts)
|
|
}
|
|
if ts.Interval != i {
|
|
t.Error("Interval not attached correctly")
|
|
}
|
|
|
|
if ts.GetDuration().Seconds() != 29*60 || nts.GetDuration().Seconds() != 1*60 {
|
|
t.Error("Wrong durations.for Intervals", ts.GetDuration().Seconds(), nts.GetDuration().Seconds())
|
|
}
|
|
if ts.GetDuration().Seconds()+nts.GetDuration().Seconds() != oldDuration.Seconds() {
|
|
t.Errorf("The duration has changed: %v + %v != %v", ts.GetDuration().Seconds(), nts.GetDuration().Seconds(), oldDuration.Seconds())
|
|
}
|
|
}
|
|
|
|
func TestLeftMargin(t *testing.T) {
|
|
i := &Interval{WeekDays: []time.Weekday{time.Monday, time.Tuesday, time.Wednesday, time.Thursday, time.Friday}}
|
|
t1 := time.Date(2012, time.February, 5, 23, 45, 0, 0, time.UTC)
|
|
t2 := time.Date(2012, time.February, 6, 0, 10, 0, 0, time.UTC)
|
|
ts := &TimeSpan{TimeStart: t1, TimeEnd: t2}
|
|
oldDuration := ts.GetDuration()
|
|
nts := ts.SplitByInterval(i)
|
|
if ts.TimeStart != t1 || ts.TimeEnd != time.Date(2012, time.February, 6, 0, 0, 0, 0, time.UTC) {
|
|
t.Error("Incorrect first half", ts)
|
|
}
|
|
if nts.TimeStart != time.Date(2012, time.February, 6, 0, 0, 0, 0, time.UTC) || nts.TimeEnd != t2 {
|
|
t.Error("Incorrect second half", nts)
|
|
}
|
|
if nts.Interval != i {
|
|
t.Error("Interval not attached correctly")
|
|
}
|
|
if ts.GetDuration().Seconds() != 15*60 || nts.GetDuration().Seconds() != 10*60 {
|
|
t.Error("Wrong durations.for Intervals", ts.GetDuration().Seconds(), nts.GetDuration().Seconds())
|
|
}
|
|
if ts.GetDuration().Seconds()+nts.GetDuration().Seconds() != oldDuration.Seconds() {
|
|
t.Errorf("The duration has changed: %v + %v != %v", ts.GetDuration().Seconds(), nts.GetDuration().Seconds(), oldDuration.Seconds())
|
|
}
|
|
}
|
|
|
|
func TestLeftHourMargin(t *testing.T) {
|
|
i := &Interval{Months: Months{time.December}, MonthDays: MonthDays{1}, StartTime: "09:00:00"}
|
|
t1 := time.Date(2012, time.December, 1, 8, 45, 0, 0, time.UTC)
|
|
t2 := time.Date(2012, time.December, 1, 9, 20, 0, 0, time.UTC)
|
|
ts := &TimeSpan{TimeStart: t1, TimeEnd: t2}
|
|
oldDuration := ts.GetDuration()
|
|
nts := ts.SplitByInterval(i)
|
|
if ts.TimeStart != t1 || ts.TimeEnd != time.Date(2012, time.December, 1, 9, 0, 0, 0, time.UTC) {
|
|
t.Error("Incorrect first half", ts)
|
|
}
|
|
if nts.TimeStart != time.Date(2012, time.December, 1, 9, 0, 0, 0, time.UTC) || nts.TimeEnd != t2 {
|
|
t.Error("Incorrect second half", nts)
|
|
}
|
|
if nts.Interval != i {
|
|
t.Error("Interval not attached correctly")
|
|
}
|
|
if ts.GetDuration().Seconds() != 15*60 || nts.GetDuration().Seconds() != 20*60 {
|
|
t.Error("Wrong durations.for Intervals", ts.GetDuration().Seconds(), nts.GetDuration().Seconds())
|
|
}
|
|
if ts.GetDuration().Seconds()+nts.GetDuration().Seconds() != oldDuration.Seconds() {
|
|
t.Errorf("The duration has changed: %v + %v != %v", ts.GetDuration().Seconds(), nts.GetDuration().Seconds(), oldDuration.Seconds())
|
|
}
|
|
}
|
|
|
|
func TestEnclosingMargin(t *testing.T) {
|
|
i := &Interval{WeekDays: []time.Weekday{time.Sunday}}
|
|
t1 := time.Date(2012, time.February, 5, 17, 45, 0, 0, time.UTC)
|
|
t2 := time.Date(2012, time.February, 5, 18, 10, 0, 0, time.UTC)
|
|
ts := &TimeSpan{TimeStart: t1, TimeEnd: t2}
|
|
nts := ts.SplitByInterval(i)
|
|
if ts.TimeStart != t1 || ts.TimeEnd != t2 || nts != nil {
|
|
t.Error("Incorrect enclosing", ts)
|
|
}
|
|
if ts.Interval != i {
|
|
t.Error("Interval not attached correctly")
|
|
}
|
|
}
|
|
|
|
func TestOutsideMargin(t *testing.T) {
|
|
i := &Interval{WeekDays: []time.Weekday{time.Monday}}
|
|
t1 := time.Date(2012, time.February, 5, 17, 45, 0, 0, time.UTC)
|
|
t2 := time.Date(2012, time.February, 5, 18, 10, 0, 0, time.UTC)
|
|
ts := &TimeSpan{TimeStart: t1, TimeEnd: t2}
|
|
result := ts.SplitByInterval(i)
|
|
if result != nil {
|
|
t.Error("Interval not split correctly")
|
|
}
|
|
}
|
|
|
|
func TestContains(t *testing.T) {
|
|
t1 := time.Date(2012, time.February, 5, 17, 45, 0, 0, time.UTC)
|
|
t2 := time.Date(2012, time.February, 5, 17, 55, 0, 0, time.UTC)
|
|
t3 := time.Date(2012, time.February, 5, 17, 50, 0, 0, time.UTC)
|
|
ts := TimeSpan{TimeStart: t1, TimeEnd: t2}
|
|
if ts.Contains(t1) {
|
|
t.Error("It should NOT contain ", t1)
|
|
}
|
|
if ts.Contains(t2) {
|
|
t.Error("It should NOT contain ", t1)
|
|
}
|
|
if !ts.Contains(t3) {
|
|
t.Error("It should contain ", t3)
|
|
}
|
|
}
|
|
|
|
func TestSplitByActivationTime(t *testing.T) {
|
|
t1 := time.Date(2012, time.February, 5, 17, 45, 0, 0, time.UTC)
|
|
t2 := time.Date(2012, time.February, 5, 17, 55, 0, 0, time.UTC)
|
|
t3 := time.Date(2012, time.February, 5, 17, 50, 0, 0, time.UTC)
|
|
ts := TimeSpan{TimeStart: t1, TimeEnd: t2}
|
|
ap1 := &ActivationPeriod{ActivationTime: t1}
|
|
ap2 := &ActivationPeriod{ActivationTime: t2}
|
|
ap3 := &ActivationPeriod{ActivationTime: t3}
|
|
|
|
if ts.SplitByActivationPeriod(ap1) != nil {
|
|
t.Error("Error spliting on left margin")
|
|
}
|
|
if ts.SplitByActivationPeriod(ap2) != nil {
|
|
t.Error("Error spliting on right margin")
|
|
}
|
|
result := ts.SplitByActivationPeriod(ap3)
|
|
if result.TimeStart != t3 || result.TimeEnd != t2 {
|
|
t.Error("Error spliting on interior")
|
|
}
|
|
}
|
|
|
|
func TestTimespanGetCost(t *testing.T) {
|
|
t1 := time.Date(2012, time.February, 5, 17, 45, 0, 0, time.UTC)
|
|
t2 := time.Date(2012, time.February, 5, 17, 55, 0, 0, time.UTC)
|
|
ts1 := TimeSpan{TimeStart: t1, TimeEnd: t2}
|
|
cd := &CallDescriptor{Subject: "other"}
|
|
if ts1.getCost(cd) != 0 {
|
|
t.Error("No interval and still kicking")
|
|
}
|
|
ts1.Interval = &Interval{Prices: PriceGroups{&Price{0, 1.0, 1}}}
|
|
if ts1.getCost(cd) != 600 {
|
|
t.Error("Expected 10 got ", ts1.getCost(cd))
|
|
}
|
|
ts1.Interval.PricedUnits = 60
|
|
if ts1.getCost(cd) != 10 {
|
|
t.Error("Expected 6000 got ", ts1.getCost(cd))
|
|
}
|
|
}
|
|
|
|
func TestSetInterval(t *testing.T) {
|
|
i1 := &Interval{Prices: PriceGroups{&Price{0, 1.0, 1}}}
|
|
ts1 := TimeSpan{Interval: i1}
|
|
i2 := &Interval{Prices: PriceGroups{&Price{0, 2.0, 1}}}
|
|
ts1.SetInterval(i2)
|
|
if ts1.Interval != i1 {
|
|
t.Error("Smaller price interval should win")
|
|
}
|
|
i2.Weight = 1
|
|
ts1.SetInterval(i2)
|
|
if ts1.Interval != i2 {
|
|
t.Error("Bigger ponder interval should win")
|
|
}
|
|
}
|
|
|
|
func TestTimespanSplitByMinuteBucketPlenty(t *testing.T) {
|
|
t1 := time.Date(2013, time.July, 15, 10, 40, 0, 0, time.UTC)
|
|
t2 := time.Date(2013, time.July, 15, 10, 42, 0, 0, time.UTC)
|
|
mb := &MinuteBucket{Seconds: 180}
|
|
ts := TimeSpan{TimeStart: t1, TimeEnd: t2}
|
|
newTs := ts.SplitByMinuteBucket(mb)
|
|
if ts.MinuteInfo == nil || ts.MinuteInfo.Quantity != 120 {
|
|
t.Error("Not enough minutes on minute bucket split")
|
|
}
|
|
if newTs != nil {
|
|
t.Error("Bad extra timespan on minute bucket split")
|
|
}
|
|
}
|
|
|
|
func TestTimespanSplitByMinuteBucketScarce(t *testing.T) {
|
|
t1 := time.Date(2013, time.July, 15, 10, 40, 0, 0, time.UTC)
|
|
t2 := time.Date(2013, time.July, 15, 10, 42, 0, 0, time.UTC)
|
|
mb := &MinuteBucket{Seconds: 60}
|
|
ts := TimeSpan{TimeStart: t1, TimeEnd: t2}
|
|
newTs := ts.SplitByMinuteBucket(mb)
|
|
if ts.MinuteInfo == nil || ts.MinuteInfo.Quantity != 60 {
|
|
t.Error("Not enough minutes on minute bucket split")
|
|
}
|
|
if newTs == nil || newTs.MinuteInfo != nil {
|
|
t.Error("Missing extra timespan on minute bucket split")
|
|
}
|
|
}
|
|
|
|
func TestTimespanSplitByMinuteBucketPlantyExpired(t *testing.T) {
|
|
t1 := time.Date(2013, time.July, 15, 10, 40, 0, 0, time.UTC)
|
|
t2 := time.Date(2013, time.July, 15, 10, 42, 0, 0, time.UTC)
|
|
mb := &MinuteBucket{Seconds: 180, ExpirationDate: time.Date(2013, time.July, 15, 10, 39, 0, 0, time.UTC)}
|
|
ts := TimeSpan{TimeStart: t1, TimeEnd: t2}
|
|
newTs := ts.SplitByMinuteBucket(mb)
|
|
if ts.MinuteInfo != nil {
|
|
t.Error("Not enough minutes on minute bucket split")
|
|
}
|
|
if newTs != nil {
|
|
t.Error("Bad extra timespan on minute bucket split")
|
|
}
|
|
}
|
|
|
|
func TestTimespanSplitByMinuteBucketPlantyExpiring(t *testing.T) {
|
|
t1 := time.Date(2013, time.July, 15, 10, 40, 0, 0, time.UTC)
|
|
t2 := time.Date(2013, time.July, 15, 10, 42, 0, 0, time.UTC)
|
|
mb := &MinuteBucket{Seconds: 180, ExpirationDate: time.Date(2013, time.July, 15, 10, 41, 0, 0, time.UTC)}
|
|
ts := TimeSpan{TimeStart: t1, TimeEnd: t2}
|
|
newTs := ts.SplitByMinuteBucket(mb)
|
|
if ts.MinuteInfo == nil || ts.MinuteInfo.Quantity != 60 {
|
|
t.Error("Not enough minutes on minute bucket split")
|
|
}
|
|
if newTs == nil || newTs.MinuteInfo != nil {
|
|
t.Error("Missing extra timespan on minute bucket split")
|
|
}
|
|
}
|
|
|
|
func TestTimespanSplitByMinuteBucketPlantyExpiringEnd(t *testing.T) {
|
|
t1 := time.Date(2013, time.July, 15, 10, 40, 0, 0, time.UTC)
|
|
t2 := time.Date(2013, time.July, 15, 10, 42, 0, 0, time.UTC)
|
|
mb := &MinuteBucket{Seconds: 180, ExpirationDate: time.Date(2013, time.July, 15, 10, 42, 0, 0, time.UTC)}
|
|
ts := TimeSpan{TimeStart: t1, TimeEnd: t2}
|
|
newTs := ts.SplitByMinuteBucket(mb)
|
|
if ts.MinuteInfo == nil || ts.MinuteInfo.Quantity != 120 {
|
|
t.Error("Not enough minutes on minute bucket split")
|
|
}
|
|
if newTs != nil {
|
|
t.Error("Missing extra timespan on minute bucket split")
|
|
}
|
|
}
|
|
|
|
func TestTimespanSplitByMinuteBucketScarceExpiringSame(t *testing.T) {
|
|
t1 := time.Date(2013, time.July, 15, 10, 40, 0, 0, time.UTC)
|
|
t2 := time.Date(2013, time.July, 15, 10, 42, 0, 0, time.UTC)
|
|
mb := &MinuteBucket{Seconds: 120, ExpirationDate: time.Date(2013, time.July, 15, 10, 41, 0, 0, time.UTC)}
|
|
ts := TimeSpan{TimeStart: t1, TimeEnd: t2}
|
|
newTs := ts.SplitByMinuteBucket(mb)
|
|
if ts.MinuteInfo == nil || ts.MinuteInfo.Quantity != 60 {
|
|
t.Error("Not enough minutes on minute bucket split")
|
|
}
|
|
if newTs == nil || newTs.MinuteInfo != nil {
|
|
t.Error("Missing extra timespan on minute bucket split")
|
|
}
|
|
}
|
|
|
|
func TestTimespanSplitByMinuteBucketScarceExpiringDifferentExpFirst(t *testing.T) {
|
|
t1 := time.Date(2013, time.July, 15, 10, 40, 0, 0, time.UTC)
|
|
t2 := time.Date(2013, time.July, 15, 10, 42, 0, 0, time.UTC)
|
|
mb := &MinuteBucket{Seconds: 140, ExpirationDate: time.Date(2013, time.July, 15, 10, 41, 1, 0, time.UTC)}
|
|
ts := TimeSpan{TimeStart: t1, TimeEnd: t2}
|
|
newTs := ts.SplitByMinuteBucket(mb)
|
|
if ts.MinuteInfo == nil || ts.MinuteInfo.Quantity != 61 {
|
|
t.Error("Not enough minutes on minute bucket split: ", ts.MinuteInfo.Quantity)
|
|
}
|
|
if newTs == nil || newTs.MinuteInfo != nil {
|
|
t.Error("Missing extra timespan on minute bucket split")
|
|
}
|
|
}
|
|
|
|
func TestTimespanSplitByMinuteBucketScarceExpiringDifferentScarceFirst(t *testing.T) {
|
|
t1 := time.Date(2013, time.July, 15, 10, 40, 0, 0, time.UTC)
|
|
t2 := time.Date(2013, time.July, 15, 10, 42, 0, 0, time.UTC)
|
|
mb := &MinuteBucket{Seconds: 61, ExpirationDate: time.Date(2013, time.July, 15, 10, 41, 30, 0, time.UTC)}
|
|
ts := TimeSpan{TimeStart: t1, TimeEnd: t2}
|
|
newTs := ts.SplitByMinuteBucket(mb)
|
|
if ts.MinuteInfo == nil || ts.MinuteInfo.Quantity != 61 {
|
|
t.Error("Not enough minutes on minute bucket split")
|
|
}
|
|
if newTs == nil || newTs.MinuteInfo != nil {
|
|
t.Error("Missing extra timespan on minute bucket split")
|
|
}
|
|
}
|
|
|
|
func TestTimespanSplitGroupedRates(t *testing.T) {
|
|
i := &Interval{
|
|
EndTime: "17:59:00",
|
|
Prices: PriceGroups{&Price{0, 2, 1}, &Price{900, 1, 1}},
|
|
}
|
|
t1 := time.Date(2012, time.February, 3, 17, 30, 0, 0, time.UTC)
|
|
t2 := time.Date(2012, time.February, 3, 18, 00, 0, 0, time.UTC)
|
|
ts := &TimeSpan{TimeStart: t1, TimeEnd: t2, CallDuration: 1800}
|
|
oldDuration := ts.GetDuration()
|
|
nts := ts.SplitByInterval(i)
|
|
splitTime := time.Date(2012, time.February, 3, 17, 45, 00, 0, time.UTC)
|
|
if ts.TimeStart != t1 || ts.TimeEnd != splitTime {
|
|
t.Error("Incorrect first half", ts)
|
|
}
|
|
if nts.TimeStart != splitTime || nts.TimeEnd != t2 {
|
|
t.Error("Incorrect second half", nts)
|
|
}
|
|
if ts.Interval != i {
|
|
t.Error("Interval not attached correctly")
|
|
}
|
|
c1 := ts.Interval.GetCost(ts.GetDuration().Seconds(), ts.GetGroupStart())
|
|
c2 := nts.Interval.GetCost(nts.GetDuration().Seconds(), nts.GetGroupStart())
|
|
if c1 != 1800 || c2 != 900 {
|
|
t.Error("Wrong costs: ", c1, c2)
|
|
}
|
|
|
|
if ts.GetDuration().Seconds() != 15*60 || nts.GetDuration().Seconds() != 15*60 {
|
|
t.Error("Wrong durations.for Intervals", ts.GetDuration().Seconds(), nts.GetDuration().Seconds())
|
|
}
|
|
if ts.GetDuration().Seconds()+nts.GetDuration().Seconds() != oldDuration.Seconds() {
|
|
t.Errorf("The duration has changed: %v + %v != %v", ts.GetDuration().Seconds(), nts.GetDuration().Seconds(), oldDuration.Seconds())
|
|
}
|
|
}
|
|
|
|
func TestTimespanSplitGroupedRatesIncrements(t *testing.T) {
|
|
i := &Interval{
|
|
EndTime: "17:59:00",
|
|
Prices: PriceGroups{&Price{0, 2, 1}, &Price{30, 1, 60}},
|
|
}
|
|
t1 := time.Date(2012, time.February, 3, 17, 30, 0, 0, time.UTC)
|
|
t2 := time.Date(2012, time.February, 3, 17, 31, 0, 0, time.UTC)
|
|
ts := &TimeSpan{TimeStart: t1, TimeEnd: t2, CallDuration: 60}
|
|
oldDuration := ts.GetDuration()
|
|
nts := ts.SplitByInterval(i)
|
|
splitTime := time.Date(2012, time.February, 3, 17, 30, 30, 0, time.UTC)
|
|
if ts.TimeStart != t1 || ts.TimeEnd != splitTime {
|
|
t.Error("Incorrect first half", ts)
|
|
}
|
|
if nts.TimeStart != splitTime || nts.TimeEnd != t2 {
|
|
t.Error("Incorrect second half", nts)
|
|
}
|
|
if ts.Interval != i {
|
|
t.Error("Interval not attached correctly")
|
|
}
|
|
c1 := ts.Interval.GetCost(ts.GetDuration().Seconds(), ts.GetGroupStart())
|
|
c2 := nts.Interval.GetCost(nts.GetDuration().Seconds(), nts.GetGroupStart())
|
|
if c1 != 60 || c2 != 60 {
|
|
t.Error("Wrong costs: ", c1, c2)
|
|
}
|
|
|
|
if ts.GetDuration().Seconds() != 0.5*60 || nts.GetDuration().Seconds() != 0.5*60 {
|
|
t.Error("Wrong durations.for Intervals", ts.GetDuration().Seconds(), nts.GetDuration().Seconds())
|
|
}
|
|
if ts.GetDuration().Seconds()+nts.GetDuration().Seconds() != oldDuration.Seconds() {
|
|
t.Errorf("The duration has changed: %v + %v != %v", ts.GetDuration().Seconds(), nts.GetDuration().Seconds(), oldDuration.Seconds())
|
|
}
|
|
}
|
|
|
|
func TestTimespanSplitRightHourMarginBeforeGroup(t *testing.T) {
|
|
i := &Interval{
|
|
EndTime: "17:00:30",
|
|
Prices: PriceGroups{&Price{0, 2, 1}, &Price{60, 1, 60}},
|
|
}
|
|
t1 := time.Date(2012, time.February, 3, 17, 00, 0, 0, time.UTC)
|
|
t2 := time.Date(2012, time.February, 3, 17, 01, 0, 0, time.UTC)
|
|
ts := &TimeSpan{TimeStart: t1, TimeEnd: t2}
|
|
oldDuration := ts.GetDuration()
|
|
nts := ts.SplitByInterval(i)
|
|
splitTime := time.Date(2012, time.February, 3, 17, 00, 30, 0, time.UTC)
|
|
if ts.TimeStart != t1 || ts.TimeEnd != splitTime {
|
|
t.Error("Incorrect first half", ts)
|
|
}
|
|
if nts.TimeStart != splitTime || nts.TimeEnd != t2 {
|
|
t.Error("Incorrect second half", nts)
|
|
}
|
|
if ts.Interval != i {
|
|
t.Error("Interval not attached correctly")
|
|
}
|
|
|
|
if ts.GetDuration().Seconds() != 30 || nts.GetDuration().Seconds() != 30 {
|
|
t.Error("Wrong durations.for Intervals", ts.GetDuration().Seconds(), nts.GetDuration().Seconds())
|
|
}
|
|
if ts.GetDuration().Seconds()+nts.GetDuration().Seconds() != oldDuration.Seconds() {
|
|
t.Errorf("The duration has changed: %v + %v != %v", ts.GetDuration().Seconds(), nts.GetDuration().Seconds(), oldDuration.Seconds())
|
|
}
|
|
nnts := nts.SplitByInterval(i)
|
|
if nnts != nil {
|
|
t.Error("Bad new split", nnts)
|
|
}
|
|
}
|
|
|
|
func TestTimespanSplitGroupSecondSplit(t *testing.T) {
|
|
i := &Interval{
|
|
EndTime: "17:03:30",
|
|
Prices: PriceGroups{&Price{0, 2, 1}, &Price{60, 1, 1}},
|
|
}
|
|
t1 := time.Date(2012, time.February, 3, 17, 00, 0, 0, time.UTC)
|
|
t2 := time.Date(2012, time.February, 3, 17, 04, 0, 0, time.UTC)
|
|
ts := &TimeSpan{TimeStart: t1, TimeEnd: t2, CallDuration: 240}
|
|
oldDuration := ts.GetDuration()
|
|
nts := ts.SplitByInterval(i)
|
|
splitTime := time.Date(2012, time.February, 3, 17, 01, 00, 0, time.UTC)
|
|
if ts.TimeStart != t1 || ts.TimeEnd != splitTime {
|
|
t.Error("Incorrect first half", nts)
|
|
}
|
|
if nts.TimeStart != splitTime || nts.TimeEnd != t2 {
|
|
t.Error("Incorrect second half", nts)
|
|
}
|
|
if ts.Interval != i {
|
|
t.Error("Interval not attached correctly")
|
|
}
|
|
|
|
if ts.GetDuration().Seconds() != 60 || nts.GetDuration().Seconds() != 180 {
|
|
t.Error("Wrong durations.for Intervals", ts.GetDuration().Seconds(), nts.GetDuration().Seconds())
|
|
}
|
|
if ts.GetDuration().Seconds()+nts.GetDuration().Seconds() != oldDuration.Seconds() {
|
|
t.Errorf("The duration has changed: %v + %v != %v", ts.GetDuration().Seconds(), nts.GetDuration().Seconds(), oldDuration.Seconds())
|
|
}
|
|
nnts := nts.SplitByInterval(i)
|
|
nsplitTime := time.Date(2012, time.February, 3, 17, 03, 30, 0, time.UTC)
|
|
if nts.TimeStart != splitTime || nts.TimeEnd != nsplitTime {
|
|
t.Error("Incorrect first half", nts)
|
|
}
|
|
if nnts.TimeStart != nsplitTime || nnts.TimeEnd != t2 {
|
|
t.Error("Incorrect second half", nnts)
|
|
}
|
|
if nts.Interval != i {
|
|
t.Error("Interval not attached correctly")
|
|
}
|
|
|
|
if nts.GetDuration().Seconds() != 150 || nnts.GetDuration().Seconds() != 30 {
|
|
t.Error("Wrong durations.for Intervals", nts.GetDuration().Seconds(), nnts.GetDuration().Seconds())
|
|
}
|
|
}
|
|
|
|
func TestTimespanSplitMultipleGroup(t *testing.T) {
|
|
i := &Interval{
|
|
EndTime: "17:05:00",
|
|
Prices: PriceGroups{&Price{0, 2, 1}, &Price{60, 1, 1}, &Price{180, 1, 1}},
|
|
}
|
|
t1 := time.Date(2012, time.February, 3, 17, 00, 0, 0, time.UTC)
|
|
t2 := time.Date(2012, time.February, 3, 17, 04, 0, 0, time.UTC)
|
|
ts := &TimeSpan{TimeStart: t1, TimeEnd: t2, CallDuration: 240}
|
|
oldDuration := ts.GetDuration()
|
|
nts := ts.SplitByInterval(i)
|
|
splitTime := time.Date(2012, time.February, 3, 17, 01, 00, 0, time.UTC)
|
|
if ts.TimeStart != t1 || ts.TimeEnd != splitTime {
|
|
t.Error("Incorrect first half", nts)
|
|
}
|
|
if nts.TimeStart != splitTime || nts.TimeEnd != t2 {
|
|
t.Error("Incorrect second half", nts)
|
|
}
|
|
if ts.Interval != i {
|
|
t.Error("Interval not attached correctly")
|
|
}
|
|
|
|
if ts.GetDuration().Seconds() != 60 || nts.GetDuration().Seconds() != 180 {
|
|
t.Error("Wrong durations.for Intervals", ts.GetDuration().Seconds(), nts.GetDuration().Seconds())
|
|
}
|
|
if ts.GetDuration().Seconds()+nts.GetDuration().Seconds() != oldDuration.Seconds() {
|
|
t.Errorf("The duration has changed: %v + %v != %v", ts.GetDuration().Seconds(), nts.GetDuration().Seconds(), oldDuration.Seconds())
|
|
}
|
|
nnts := nts.SplitByInterval(i)
|
|
nsplitTime := time.Date(2012, time.February, 3, 17, 03, 00, 0, time.UTC)
|
|
if nts.TimeStart != splitTime || nts.TimeEnd != nsplitTime {
|
|
t.Error("Incorrect first half", nts)
|
|
}
|
|
if nnts.TimeStart != nsplitTime || nnts.TimeEnd != t2 {
|
|
t.Error("Incorrect second half", nnts)
|
|
}
|
|
if nts.Interval != i {
|
|
t.Error("Interval not attached correctly")
|
|
}
|
|
|
|
if nts.GetDuration().Seconds() != 120 || nnts.GetDuration().Seconds() != 60 {
|
|
t.Error("Wrong durations.for Intervals", nts.GetDuration().Seconds(), nnts.GetDuration().Seconds())
|
|
}
|
|
}
|