time-arrow/core_test.go

package time_arrow

import (
	"fmt"
	"math/rand"
	"reflect"
	"testing"
	"time"
)

func Test_isInWeekOfDay(t *testing.T) {
	ti, err := time.ParseInLocation("2006-01-02 15:04:05", "2020-06-08 00:00:00", time.Local)
	if err != nil {
		panic(err)
	}
	ok := isInWeekOfDay(ti, TimeArrow{
		DayOfWeek: []int{
			1,
			3,
		},
	})
	if !ok {
		t.Fatal("error")
	}
	ok = isInWeekOfDay(ti, TimeArrow{
		DayOfWeek: []int{
			6,
			3,
			2,
		},
	})
	if ok {
		t.Fatal("error")
	}
	ok = isInWeekOfDay(ti, TimeArrow{})
	if ok {
		t.Fatal("error")
	}
}

func Test_timeCompletion(t *testing.T) {
	if timeCompletion("12") != "12:00:00" {
		t.Fatal("error")
	}
	if timeCompletion("17:00") != "17:00:00" {
		t.Fatal("error")
	}
}

func Test_isInTimeOfDay(t *testing.T) {
	rand.Seed(time.Now().Unix())
	for k := 0; k < 300; k++ {
		rt := rand.Int() % 24
		rm := rand.Int() % 60
		ti, err := time.ParseInLocation("2006-01-02 15:04:05", fmt.Sprintf("2020-06-08 %.2d:%.2d:00", rt, rm), time.Local)
		if err != nil {
			panic(err)
		}
		ok := isInTimeOfDay(ti, TimeArrow{
			TimesOnDay: []string{
				"1:21",
				"1:21-2:22",
				"17:00-18:00",
			},
		})
		ok2 := isInTimeOfDay(ti, TimeArrow{
			TimesOnDay: []string{
				"1:21",
				"1:21-2:22",
				"17:00-18:00",
			},
		})
		if ok != ok2 {
			t.Fatal("error")
		}

		ok = isInTimeOfDay(ti, TimeArrow{
			TimesOnDay: []string{
				"17:00-17:10",
				"18:00-19:00",
			},
		})
		ok2 = isInTimeOfDay2(ti, TimeArrow{
			TimesOnDay: []string{
				"17:00-17:10",
				"18:00-19:00",
			},
		})
		if ok != ok2 {
			t.Fatal("error")
		}

		tss := []string{}
		for i := 0; i < 24; i++ {
			tss = append(tss, fmt.Sprintf("%d:00-%d:30", i, i))
			tss = append(tss, fmt.Sprintf("%d:30-%d:00", i, i+1))
		}

		ok = isInTimeOfDay(ti, TimeArrow{
			TimesOnDay: tss,
		})

		ok2 = isInTimeOfDay2(ti, TimeArrow{
			TimesOnDay: tss,
		})
		if ok != ok2 {
			t.Fatal("error")
		}

		tss = []string{}
		for i := 0; i < 24; i++ {
			if i == rt {
				continue
			}
			tss = append(tss, fmt.Sprintf("%d:00-%d:30", i, i))
			tss = append(tss, fmt.Sprintf("%d:30-%d:00", i, i+1))
		}

		ok = isInTimeOfDay(ti, TimeArrow{
			TimesOnDay: tss,
		})
		ok2 = isInTimeOfDay2(ti, TimeArrow{
			TimesOnDay: tss,
		})
		if ok != ok2 {
			t.Fatal("error")
		}
	}
}

func Test_isInDateSlice(t *testing.T) {
	ti, err := time.ParseInLocation("2006-01-02 15:04:05", "2020-06-08 17:18:00", time.Local)
	if err != nil {
		panic(err)
	}

	ok := isInDateSlice(ti, TimeArrow{
		DateSlice: []DateSlice{},
	})

	if ok {
		t.Fatal("error")
	}

	ok = isInDateSlice(ti, TimeArrow{
		DateSlice: []DateSlice{
			{
				Start: "2020-06-05 17:18",
				End:   "2020-06-07",
			},
		},
	})

	if ok {
		t.Fatal("error")
	}

	ok = isInDateSlice(ti, TimeArrow{
		DateSlice: []DateSlice{
			{
				Start: "2020-06-05 17:18",
				End:   "2020-06-07",
			},
			{
				Start: "2020-06-07 17:18",
				End:   "2020-06-09",
			},
		},
	})

	if !ok {
		t.Fatal("error")
	}
}

func Test_isInExpandTags(t *testing.T) {
	ok := isInExpandTags(TimeArrow{
		ExpandTags: []string{},
	}, "一号场")

	if !ok {
		t.Fatal("error")
	}

	ok = isInExpandTags(TimeArrow{
		ExpandTags: []string{
			"一号场",
			"二号场",
			"四号场",
		},
	}, "一号场")

	if !ok {
		t.Fatal("error")
	}

	ok = isInExpandTags(TimeArrow{
		ExpandTags: []string{
			"一号场",
			"二号场",
			"四号场",
		},
	}, "三号场")

	if ok {
		t.Fatal("error")
	}

}

var th TimeArrowHelper

func TestGetHitTimeArrow(t *testing.T) {
	tas := TimeArrows{
		{
			Type: TimeArrowTypeDayOfWeek,
			DayOfWeek: []int{
				0,
				1,
				2,
				3,
				4,
				5,
				6,
			},
			ExpandTags: []string{
				"一号场",
				"二号场",
				"三号场",
				"四号场",
			},
			ExpandValue: 0,
			Weights:     0,
		},
		{
			Type: TimeArrowTypeDayOfWeek,
			DayOfWeek: []int{
				6,
				0,
			},
			ExpandTags: []string{
				"一号场",
				"二号场",
				"四号场",
			},
			ExpandValue: 30,
			Weights:     1,
		},
		{
			Type: TimeArrowTypeDayOfWeek,
			DayOfWeek: []int{
				6,
				0,
			},
			ExpandTags: []string{
				"三号场",
			},
			ExpandValue: 60,
			Weights:     1,
		},
		{
			Type: TimeArrowTypeDayOfMonth,
			DayOfMonth: []int{
				3,
				5,
			},
			ExpandValue: 12,
			Weights:     2,
		},
		{
			Type: TimeArrowTypeDateSlice,
			DateSlice: []DateSlice{
				{
					Start: "2020-04-05",
					End:   "2020-05-05",
				},
				{
					Start: "2020-06-07 17:18",
					End:   "2020-06-09",
				},
			},
			ExpandValue: 5,
			Weights:     3,
		},
		{
			Type: TimeArrowTypeDateSlice,
			DateSlice: []DateSlice{
				{
					Start: "2020-04-05",
					End:   "2020-05-05",
				},
				{
					Start: "2020-06-07 17:18",
					End:   "2020-06-09",
				},
			},
			TimesOnDay: []string{
				"18-19",
			},
			ExpandValue: 180,
			Weights:     4,
		},
	}

	th.GetData = func(group string) (arrows TimeArrows, e error) {
		return tas, nil
	}

	ti, err := time.ParseInLocation("2006-01-02 15:04:05", "2020-06-01 17:18:00", time.Local)
	if err != nil {
		panic(err)
	}

	result, err := th.GetHitTimeArrow(ti, "", "一号场")
	if err != nil || result == nil {
		t.Fatal("error")
		panic(err)
	}

	if result.ExpandValue.(int) != 0 {
		t.Fatal("error")
	}

	ti = ti.AddDate(0, 0, -1)
	result, err = th.GetHitTimeArrow(ti, "", "一号场")
	if err != nil || result == nil {
		t.Fatal("error")
		panic(err)
	}

	if result.ExpandValue.(int) != 30 {
		t.Fatal("error", result.ExpandValue.(int))
	}
	result, err = th.GetHitTimeArrow(ti, "", "三号场")
	if err != nil || result == nil {
		t.Fatal("error")
		panic(err)
	}

	if result.ExpandValue.(int) != 60 {
		t.Fatal("error")
	}

	ti, err = time.ParseInLocation("2006-01-02 15:04:05", "2020-04-11 17:18:00", time.Local)
	if err != nil {
		panic(err)
	}

	result, err = th.GetHitTimeArrow(ti, "", "三号场")
	if err != nil || result == nil {
		t.Fatal("error")
		panic(err)
	}

	if result.ExpandValue.(int) != 5 {
		t.Fatal("error")
	}

	ti = ti.Add(time.Hour)
	result, err = th.GetHitTimeArrow(ti, "", "三号场")
	if err != nil || result == nil {
		t.Fatal("error")
		panic(err)
	}

	if result.ExpandValue.(int) != 180 {
		t.Fatal("error")
	}

}

func Test_isInDayOfMonth(t *testing.T) {
	type args struct {
		t  time.Time
		ta TimeArrow
	}
	tests := []struct {
		name string
		args args
		want bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := isInDayOfMonth(tt.args.t, tt.args.ta); got != tt.want {
				t.Errorf("isInDayOfMonth() = %v, want %v", got, tt.want)
			}
		})
	}
}

func Test_isInHolidays(t *testing.T) {
	GetHolidaysData = func() (items []HolidaysItem, e error) {
		start, _ := time.Parse("2006-01-02 15:04:05", "2020-10-01 00:00:00")
		end, _ := time.Parse("2006-01-02 15:04:05", "2020-10-07 23:59:59")
		return []HolidaysItem{
			{
				Name:  "国庆节",
				Start: start,
				End:   end,
			},
		}, nil
	}
	tt, _ := time.Parse("2006-01-02 15:04:05", "2020-10-03 11:00:00")
	if !isInHolidays(tt) {
		t.Fatal("error")
	}
	tt, _ = time.Parse("2006-01-02 15:04:05", "2020-10-08 11:00:00")
	if isInHolidays(tt) {
		t.Fatal("error")
	}
	tt, _ = time.Parse("2006-01-02 15:04:05", "2020-09-08 11:00:00")
	if isInHolidays(tt) {
		t.Fatal("error")
	}
}

func Test_isInAtLastDayHolidays(t *testing.T) {

	GetHolidaysData = func() (items []HolidaysItem, e error) {
		start, _ := time.Parse("2006-01-02 15:04:05", "2020-10-01 00:00:00")
		end, _ := time.Parse("2006-01-02 15:04:05", "2020-10-07 23:59:59")
		return []HolidaysItem{
			{
				Name:  "国庆节",
				Start: start,
				End:   end,
			},
		}, nil
	}
	tt, _ := time.Parse("2006-01-02 15:04:05", "2020-10-03 11:00:00")
	if isInAtLastDayHolidays(tt) {
		t.Fatal("error")
	}
	tt, _ = time.Parse("2006-01-02 15:04:05", "2020-10-08 11:00:00")
	if isInAtLastDayHolidays(tt) {
		t.Fatal("error")
	}
	tt, _ = time.Parse("2006-01-02 15:04:05", "2020-09-08 11:00:00")
	if isInAtLastDayHolidays(tt) {
		t.Fatal("error")
	}
	tt, _ = time.Parse("2006-01-02 15:04:05", "2020-10-07 11:00:00")
	if !isInAtLastDayHolidays(tt) {
		t.Fatal("error")
	}
}

func Test_isInPriorToDayHolidays(t *testing.T) {

	GetHolidaysData = func() (items []HolidaysItem, e error) {
		start, _ := time.Parse("2006-01-02 15:04:05", "2020-10-01 00:00:00")
		end, _ := time.Parse("2006-01-02 15:04:05", "2020-10-07 23:59:59")
		return []HolidaysItem{
			{
				Name:  "国庆节",
				Start: start,
				End:   end,
			},
		}, nil
	}
	tt, _ := time.Parse("2006-01-02 15:04:05", "2020-10-03 11:00:00")
	if isInPriorToDayHolidays(tt) {
		t.Fatal("error")
	}
	tt, _ = time.Parse("2006-01-02 15:04:05", "2020-10-08 11:00:00")
	if isInPriorToDayHolidays(tt) {
		t.Fatal("error")
	}
	tt, _ = time.Parse("2006-01-02 15:04:05", "2020-09-08 11:00:00")
	if isInPriorToDayHolidays(tt) {
		t.Fatal("error")
	}
	tt, _ = time.Parse("2006-01-02 15:04:05", "2020-09-30 11:00:00")
	if !isInPriorToDayHolidays(tt) {
		t.Fatal("error")
	}
}

func Test_createUUID(t *testing.T) {
	tests := []struct {
		name string
		want string
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := createUUID(); got != tt.want {
				t.Errorf("createUUID() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestCreateDayOfWeekTypePlan(t *testing.T) {
	type args struct {
		group       string
		dayOfWeek   []int
		timesOnDay  []string
		expandValue interface{}
		expandTags  []string
		weights     float64
	}
	tests := []struct {
		name string
		args args
		want TimeArrow
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := CreateDayOfWeekTypePlan(tt.args.group, tt.args.dayOfWeek, tt.args.timesOnDay, tt.args.expandValue, tt.args.expandTags, tt.args.weights); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("CreateDayOfWeekTypePlan() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestCreateDayOfMonthTypePlan(t *testing.T) {
	type args struct {
		group       string
		dayOfMonth  []int
		timesOnDay  []string
		expandValue interface{}
		expandTags  []string
		weights     float64
	}
	tests := []struct {
		name string
		args args
		want TimeArrow
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := CreateDayOfMonthTypePlan(tt.args.group, tt.args.dayOfMonth, tt.args.timesOnDay, tt.args.expandValue, tt.args.expandTags, tt.args.weights); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("CreateDayOfMonthTypePlan() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestCreateDateSliceTypePlan(t *testing.T) {
	type args struct {
		group       string
		dateSlice   []DateSlice
		timesOnDay  []string
		expandValue interface{}
		expandTags  []string
		weights     float64
	}
	tests := []struct {
		name string
		args args
		want TimeArrow
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := CreateDateSliceTypePlan(tt.args.group, tt.args.dateSlice, tt.args.timesOnDay, tt.args.expandValue, tt.args.expandTags, tt.args.weights); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("CreateDateSliceTypePlan() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestTimeArrowHelper_GetHitTimeArrow(t *testing.T) {
	type fields struct {
		GetData func(group string) (TimeArrows, error)
	}
	type args struct {
		t          time.Time
		group      string
		expandTags []string
	}
	tests := []struct {
		name    string
		fields  fields
		args    args
		want    *TimeArrow
		wantErr bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			th := &TimeArrowHelper{
				GetData: tt.fields.GetData,
			}
			got, err := th.GetHitTimeArrow(tt.args.t, tt.args.group, tt.args.expandTags...)
			if (err != nil) != tt.wantErr {
				t.Errorf("TimeArrowHelper.GetHitTimeArrow() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("TimeArrowHelper.GetHitTimeArrow() = %v, want %v", got, tt.want)
			}
		})
	}
}