kpt-pasture/util/util_test.go

package util

import (
	"fmt"
	"testing"

	"github.com/stretchr/testify/assert"
)

func TestConvertParseLocalUnix(t *testing.T) {
	type args struct {
		unix int64
	}

	tests := []struct {
		Name string
		Args args
	}{
		{
			Name: "08:00:00",
			Args: args{
				unix: 1727049600,
			},
		},
		{
			Name: "09:00:00",
			Args: args{
				unix: 1727053200,
			},
		},
	}

	for _, tt := range tests {
		t.Run(tt.Name, func(t *testing.T) {
			got, err := ConvertParseLocalUnix(tt.Name)
			assert.Nil(t, err)
			assert.Equal(t, tt.Args.unix, got)
		})
	}
}

func TestGetLastDayOfMonth(t *testing.T) {
	tests := []struct {
		month string
		got   string
	}{
		{
			month: "2022-02",
			got:   "2022-02-28",
		},
		{
			month: "2023-02",
			got:   "2023-02-28",
		},
		{
			month: "2024-02",
			got:   "2024-02-29",
		},
		{
			month: "2024-10",
			got:   "2024-10-31",
		}, {
			month: "2024-09",
			got:   "2024-09-30",
		},
	}

	for _, tt := range tests {
		t.Run(tt.month, func(t *testing.T) {
			got, err := GetLastDayOfMonth(tt.month)
			assert.Nil(t, err)
			assert.Equal(t, tt.got, got)
		})
	}
}

func TestGetMonthsInRange(t *testing.T) {
	tests := []struct {
		startMonth string
		endMonth   string
		got        []string
	}{
		{
			startMonth: "2023-01",
			endMonth:   "2023-03",
			got: []string{
				"2023-01",
				"2023-02",
				"2023-03",
			},
		},
		{
			startMonth: "2023-01",
			endMonth:   "2023-12",
			got: []string{
				"2023-01",
				"2023-02",
				"2023-03",
				"2023-04",
				"2023-05",
				"2023-06",
				"2023-07",
				"2023-08",
				"2023-09",
				"2023-10",
				"2023-11",
				"2023-12",
			},
		},
		{
			startMonth: "2023-01",
			endMonth:   "2023-01",
			got: []string{
				"2023-01",
			},
		},
		{
			startMonth: "2023-01",
			endMonth:   "2023-01",
			got: []string{
				"2023-01",
			},
		},
	}

	for _, tt := range tests {
		t.Run(tt.startMonth, func(t *testing.T) {
			got, err := GetMonthsInRange(tt.startMonth, tt.endMonth)
			assert.Nil(t, err)
			assert.Equal(t, tt.got, got)
		})
	}
}

func TestRoundToTwoDecimals(t *testing.T) {
	tests := []struct {
		exp float64
		got float64
	}{
		{
			exp: 123.456,
			got: 123.46,
		},
		{
			exp: 123.455,
			got: 123.46,
		},
		{
			exp: 123.444,
			got: 123.44,
		},
		{
			exp: 123.4551,
			got: 123.46,
		},
		{
			exp: 123.4449,
			got: 123.44,
		},
		{
			exp: 0,
			got: 0,
		},
		{
			exp: 0.2,
			got: 0.2,
		},
	}

	for _, tt := range tests {
		t.Run("TestRoundToTwoDecimals", func(t *testing.T) {
			got := RoundToTwoDecimals(tt.exp)
			assert.Equal(t, tt.got, got)
		})
	}
}

func TestGet21DayPeriods(t *testing.T) {
	tests := []struct {
		startDay string
		endDay   string
		got      struct {
			DateRange       [][]string
			Day             int32
			MiddleDayString []string
		}
	}{
		{
			startDay: "2023-01-01",
			endDay:   "2023-01-02",
			got: struct {
				DateRange       [][]string
				Day             int32
				MiddleDayString []string
			}{
				DateRange: [][]string{
					{"2022-12-13", "2023-01-02"},
				},
				Day:             11,
				MiddleDayString: []string{"2022-12-23"},
			},
		},
		{
			startDay: "2024-10-23",
			endDay:   "2024-10-24",
			got: struct {
				DateRange       [][]string
				Day             int32
				MiddleDayString []string
			}{
				DateRange: [][]string{
					{"2024-10-04", "2024-10-24"},
				},
				Day:             11,
				MiddleDayString: []string{"2024-10-14"},
			},
		},
		{
			startDay: "2024-06-22",
			endDay:   "2024-10-24",
			got: struct {
				DateRange       [][]string
				Day             int32
				MiddleDayString []string
			}{
				DateRange: [][]string{
					{"2024-06-21", "2024-07-11"},
					{"2024-07-12", "2024-08-01"},
					{"2024-08-02", "2024-08-22"},
					{"2024-08-23", "2024-09-12"},
					{"2024-09-13", "2024-10-03"},
					{"2024-10-04", "2024-10-24"},
				}, Day: 11,
				MiddleDayString: []string{"2024-07-01", "2024-07-22", "2024-08-12", "2024-09-02", "2024-09-23", "2024-10-14"},
			},
		},
	}

	for _, tt := range tests {
		t.Run(tt.startDay, func(t *testing.T) {
			got, err := Get21DayPeriods(tt.startDay, tt.endDay)
			assert.Nil(t, err)
			assert.Equal(t, tt.got.DateRange, got)
			for i, v := range tt.got.DateRange {
				middleDate, err := GetRangeDayMiddleDay(v, tt.got.Day)
				assert.Nil(t, err)
				assert.Equal(t, tt.got.MiddleDayString[i], middleDate)
			}
		})
	}
}

func TestGetRangeDayByDays(t *testing.T) {
	tests := []struct {
		startDay string
		endDay   string
		days     int32
		got      [][]string
	}{
		{
			startDay: "2024-10-23",
			endDay:   "2024-10-24",
			days:     5,
			got: [][]string{
				{"2024-10-23", "2024-10-24"},
			},
		},
		{
			startDay: "2024-10-23",
			endDay:   "2024-10-24",
			days:     1,
			got: [][]string{
				{"2024-10-23", "2024-10-23"},
				{"2024-10-24", "2024-10-24"},
			},
		},
		{
			startDay: "2024-10-01",
			endDay:   "2024-10-31",
			days:     7,
			got: [][]string{
				{"2024-10-01", "2024-10-07"},
				{"2024-10-08", "2024-10-14"},
				{"2024-10-15", "2024-10-21"},
				{"2024-10-22", "2024-10-28"},
				{"2024-10-29", "2024-10-31"},
			},
		},
		{
			startDay: "2024-10-01",
			endDay:   "2024-10-31",
			days:     5,
			got: [][]string{
				{"2024-10-01", "2024-10-05"},
				{"2024-10-06", "2024-10-10"},
				{"2024-10-11", "2024-10-15"},
				{"2024-10-16", "2024-10-20"},
				{"2024-10-21", "2024-10-25"},
				{"2024-10-26", "2024-10-30"},
				{"2024-10-31", "2024-10-31"},
			},
		},
	}

	for _, tt := range tests {
		t.Run(tt.startDay, func(t *testing.T) {
			got, err := GetRangeDayByDays(tt.startDay, tt.endDay, tt.days)
			assert.Nil(t, err)
			assert.Equal(t, tt.got, got)
		})
	}
}

func TestConfidenceInterval2(t *testing.T) {
	tests := []struct {
		p     float64
		total float64
		min   float64
		max   float64
	}{
		{
			p:     0.38,
			total: 114,
			min:   29,
			max:   47,
		},
		{
			p:     0.49,
			total: 142,
			min:   40,
			max:   58,
		},
		{
			p:     0.41,
			total: 125,
			min:   32,
			max:   50,
		},
		{
			p:     0,
			total: 0,
			min:   0,
			max:   0,
		},
	}

	for _, tt := range tests {
		min, max := ConfidenceInterval2(tt.p, tt.total)
		assert.Equal(t, tt.min, min)
		assert.Equal(t, tt.max, max)
	}
}

func TestRemoveDuplicates(t *testing.T) {
	tests := []struct {
		actual []string
		got    []string
	}{
		{
			actual: []string{
				"1", "1",
			},
			got: []string{
				"1",
			},
		},
		{
			actual: []string{
				"1", "1", "2",
			},
			got: []string{
				"1", "2",
			},
		},
		{
			actual: []string{
				"1",
			},
			got: []string{
				"1",
			},
		},
		{
			actual: []string{},
			got:    []string{},
		},
	}

	for _, tt := range tests {
		got := RemoveDuplicates(tt.actual)
		assert.Equal(t, tt.got, got)
	}

}

func TestDaysBetween(t *testing.T) {
	tests := []struct {
		actual []int64
		got    int64
	}{
		{
			actual: []int64{
				1730772000,
				1730908800,
			},
			got: 2,
		},
	}

	for _, v := range tests {
		got := DaysBetween(v.actual[0], v.actual[1])
		assert.Equal(t, got, v.got)
	}
}

func Test_demo(t *testing.T) {
	ids := make([]int64, 0)
	defer func() {
		fmt.Println(ids)
	}()
	for i := 0; i < 10; i++ {
		ids = append(ids, int64(i))
	}

	for _, v := range ids {
		fmt.Println("===v==", v)
	}
}