Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-mini-2024-07-18· OpenAIAi2 WildChat-4.8M (AI2)

mock: Unexpected Method Call ----------------------------- Update(entity.StreamEvent) 0:…

  1. User

    mock: Unexpected Method Call -----------------------------

        Update(entity.StreamEvent)
                        0: entity.StreamEvent{HoldKey:"cpa_123", Kind:"write-off", ExternalID:"123", OperationID:sql.NullInt64{Int64:456, Valid:true}, GroupID:uuid.NullUUID{UUID:uuid.UUID{0x86, 0x20, 0x97, 0x7c, 0xc1, 0x62, 0x43, 0x1b, 0xb0, 0xed, 0xa5, 0xc6, 0x30, 0xbc, 0xce, 0x24}, Valid:true}, StatusID:3, ServiceID:0, UserID:0, AmountTotal:0, AmountRUB:999, AmountBonus:777, MaxBonusRate:0, Context:entity.Context{VerticalID:(*int16)(0x14000105598), SilenceRefundedAt:time.Date(2024, time.December, 2, 16, 0, 32, 418125000, time.Local), Hold:(*bool)(0x140002f80f9)}, AppliedAt:sql.NullTime{Time:time.Date(2024, time.December, 2, 16, 0, 32, 418125000, time.Local), Valid:true}, CreatedAt:time.Date(1, time.January, 1, 0, 0, 0, 0, time.UTC), UpdatedAt:time.Date(1, time.January, 1, 0, 0, 0, 0, time.UTC)}
        
        The closest call I have is: 
        
        Update(entity.StreamEvent)
                        0: entity.StreamEvent{HoldKey:"cpa_123", Kind:"write-off", ExternalID:"123", OperationID:sql.NullInt64{Int64:456, Valid:true}, GroupID:uuid.NullUUID{UUID:uuid.UUID{0x86, 0x20, 0x97, 0x7c, 0xc1, 0x62, 0x43, 0x1b, 0xb0, 0xed, 0xa5, 0xc6, 0x30, 0xbc, 0xce, 0x24}, Valid:true}, StatusID:3, ServiceID:0, UserID:0, AmountTotal:0, AmountRUB:999, AmountBonus:777, MaxBonusRate:0, Context:entity.Context{VerticalID:(*int16)(0x14000105478), SilenceRefundedAt:time.Date(2024, time.December, 2, 16, 0, 32, 418125000, time.Local), Hold:(*bool)(nil)}, AppliedAt:sql.NullTime{Time:time.Date(2024, time.December, 2, 16, 0, 32, 418125000, time.Local), Valid:true}, CreatedAt:time.Date(1, time.January, 1, 0, 0, 0, 0, time.UTC), UpdatedAt:time.Date(1, time.January, 1, 0, 0, 0, 0, time.UTC)}
        
        Difference found in argument 0:
        
        --- Expected
        +++ Actual
        @@ -21,4 +21,4 @@
           VerticalID: (*int16)(1),
        -  SilenceRefundedAt: (*time.Time)(2024-12-02 16:00:32.418125 +0300 MSK m=+0.004258167),
        -  Hold: (*bool)(<nil>)
        +  SilenceRefundedAt: (*time.Time)(2024-12-02 16:00:32.418125 +0300 MSK),
        +  Hold: (*bool)(false)
          },
    

    golag mock тесты, почему валиться тест из за времени?

  2. Assistant

    Проблема, с которой вы столкнулись в тестах с использованием golang mock, может быть связана с тем, что структура, передаваемая в метод Update, имеет значения полей, которые не полностью совпадают с ожидаемыми.

    Из сообщения об ошибке видно, что разница заключается в поле SilenceRefundedAt и в поле Hold. Давайте рассмотрим эти два поля подробнее:

    1. SilenceRefundedAt: Даты могут выглядеть одинаково, но в вашем случае по ошибке есть упоминание (*time.Time)(...) с указанием на то, что значения различаются, возможно, на уровень точности (например, миллисекунды). Убедитесь в том, что в вашем тесте учитывается правильная точность времени. Можно использовать time.Truncate или time.Round.

    2. Hold: В одном из случаев значение указано как (*bool)(nil), а в другом как (*bool)(false). Это значит, что в одном случае поле Hold отсутствует (nil), а в другом — явно задано значение false. Если ваше поле не инициализировано (ноль), это может вызывать сбои в ваших тестах.

    Рекомендации:

    • Убедитесь, что вы создаете объект StreamEvent, который соответствует тому, что ожидается в вашем тесте.
    • Если недопустимо, чтобы какое-либо из полей было nil, проверьте, как вы инициализируете структуры в тестах и используете ли конструкторы или функции для их инициализации.
    • Рассмотрите возможность использования механизмов сравнения для полей времени, которые позволяют игнорировать различия в миллисекундах или даже секундах.
    • Проверяйте правильность инициализации поля Hold, чтобы установить его значение в соответствии с вашим ожиданием (false, если подразумевается "отсутствует", или nil, если это приемлемо).

    Сделав эти правки, вы должны получить более стабильные тесты, которые исключают ошибки, связанные с различиями в значениях полей.

  3. User

    как работает time.Truncate и time.Round ?

  4. Assistant

    В Go time.Truncate и time.Round — это методы, которые позволяют управлять точностью значений времени. Они помогают округлить время до заданного интервала. Вот как они работают:

    time.Truncate

    Метод Truncate округляет время до ближайшего меньшего значения указанного диапазона.

    Синтаксис:

    func (t Time) Truncate(d Duration) Time
    
    • t — это объект Time, который нужно округлить.
    • d — это длительность, до которой нужно округлить.

    Пример использования time.Truncate:

    t := time.Date(2024, 12, 2, 16, 0, 32, 418125000, time.Local) // дата с наносекундами
    truncated := t.Truncate(time.Second) // округление до секунды
    fmt.Println(truncated) // Вывод: 2024-12-02 16:00:32 +0300 MSK
    

    В этом примере мы округлили время до ближайшей секунды, и наносекунды обрезаются.

    time.Round

    Метод Round округляет время до ближайшего более или менее значения указанного диапазона. Он использует правила стандартного округления (ближайшее четное).

    Синтаксис:

    func (t Time) Round(d Duration) Time
    
    • t — это объект Time, который нужно округлить.
    • d — это длительность, до которой нужно округлить.

    Пример использования time.Round:

    t := time.Date(2024, 12, 2, 16, 0, 32, 500000000, time.Local) // дата с наносекундами
    rounded := t.Round(time.Second) // округление до секунды
    fmt.Println(rounded) // Вывод: 2024-12-02 16:00:33 +0300 MSK
    

    В этом примере время 32.5 секунды округляется до 33 секунд, так как оно ближе к 33, чем к 32.

    Основные отличия

    1. Метод Truncate обрезает время до указанного интервала, не опираясь на округление. Если вы укажете time.Second, то все значения, меньшие чем 1 секунда, будут сброшены, и вы получите значение со значениями нуля на месте наносекунд.
    2. Метод Round округляет до ближайшего интервала, может округлить вверх или вниз, в зависимости от значения в середине интервала.

    Выбор между Truncate и Round зависит от ваших требований — нужно ли вам просто убрать меньшую точность, или вы хотите округлить значение времени.

  5. User

    а что при выводе golang time.Time означает m+= ?

  6. Assistant

    При выводе в Go время (таймстамп), представленный структурой time.Time, может включать дополнительный параметр, такой как m+= рядом с временной меткой. Этот параметр не является частью стандартного формата вывода времени и может означать дополнительные метаданные, такие как разница во времени или какая-либо другая информация, которую вы хотите обозначить.

    Однако, если вы видите что-то вроде m+= в выводе ошибок или логах, это может быть связано с форматом, используемым в инструменте или библиотеке, которые вы используете, чтобы представить информацию о времени.

    В контексте вывода времени в Go вы обычно видите следующий формат:

    2006-01-02 15:04:05.999999999 -0700 MST
    

    Здесь:

    • 2006 — год
    • 01 — месяц
    • 02 — день
    • 15 — час
    • 04 — минута
    • 05 — секунда
    • 999999999 — наносекунды
    • -0700 — смещение часового пояса
    • MST — название часового пояса

    Если вы наблюдаете m+= в выводе, это, скорее всего, связано с конкретной реализацией вашего приложения или инструмента. Если вы не уверены в значении m+=, попробуйте обратиться к документации инструмента или библиотеки, которые вы используете, или проанализируйте вывод программы, чтобы лучше понять, откуда берется эта информация.

    Если у вас есть пример, как и где вы видите это m+=, предоставьте его, и я смогу дать более точный ответ.

  7. User

    func TestHandler_Handle_ValidationFailed(t *testing.T) { t.Parallel()

    tests := []struct {
    	name           string
    	externalID     string
    	holdKey        string
    	kind           string
    	groupID        *string
    	status         *int64
    	rub            *int64
    	bonus          *int64
    	context        *string
    	appleidAt      *time.Time
    	textErrContain string
    }{
    	// tagID 19172 handler нет external id
    	{
    		name:       "no external id",
    		externalID: "",
    		holdKey:    "cpa_123",
    		kind:       "write-off",
    		groupID:    gtc.String.ValueToPointer(uuid.New().String()),
    		status:     gtc.Int64.ValueToPointer(1),
    		context: gtc.String.ValueToPointer(
    			"{\"vertical_id\": 1, \"silence_refunded_at\": \"2006-01-02T15:04:05.000Z07:00\"}",
    		),
    		textErrContain: "externalId required",
    	},
    	// tagID 19172 handler нет hold_key
    	{
    		name:       "no hold key",
    		externalID: "123",
    		holdKey:    "",
    		kind:       "write-off",
    		groupID:    gtc.String.ValueToPointer(uuid.New().String()),
    		status:     gtc.Int64.ValueToPointer(1),
    		context: gtc.String.ValueToPointer(
    			"{\"vertical_id\": 1, \"silence_refunded_at\": \"2006-01-02T15:04:05.000Z07:00\"}",
    		),
    		textErrContain: "invalid hold key",
    	},
    	// tagID 19172 handler invalid hold_key
    	{
    		name:       "invalid hold_key",
    		externalID: "123",
    		holdKey:    "bad-hold-key",
    		kind:       "write-off",
    		groupID:    gtc.String.ValueToPointer(uuid.New().String()),
    		status:     gtc.Int64.ValueToPointer(1),
    		context: gtc.String.ValueToPointer(
    			"{\"vertical_id\": 1, \"silence_refunded_at\": \"2006-01-02T15:04:05.000Z07:00\"}",
    		),
    		textErrContain: "invalid hold key",
    	},
    	// tagID 19172 handler нет kind
    	{
    		name:       "no kind",
    		externalID: "123",
    		holdKey:    "cpa_123",
    		kind:       "",
    		groupID:    gtc.String.ValueToPointer(uuid.New().String()),
    		status:     gtc.Int64.ValueToPointer(1),
    		context: gtc.String.ValueToPointer(
    			"{\"vertical_id\": 1, \"silence_refunded_at\": \"2006-01-02T15:04:05.000Z07:00\"}",
    		),
    		textErrContain: "invalid kind",
    	},
    	// tagID 19172 handler invalid group_id
    	{
    		name:       "invalid group_id",
    		externalID: "123",
    		holdKey:    "cpa_123",
    		kind:       "write-off",
    		groupID:    gtc.String.ValueToPointer("not uuid"),
    		status:     gtc.Int64.ValueToPointer(1),
    		context: gtc.String.ValueToPointer(
    			"{\"vertical_id\": 1, \"silence_refunded_at\": \"2006-01-02T15:04:05.000Z07:00\"}",
    		),
    		textErrContain: "invalid group id",
    	},
    	// tagID 19172 handler inavlid status
    	{
    		name:       "no external id",
    		externalID: "",
    		holdKey:    "cpa_123",
    		kind:       "write-off",
    		groupID:    gtc.String.ValueToPointer(uuid.New().String()),
    		status:     gtc.Int64.ValueToPointer(10),
    		context: gtc.String.ValueToPointer(
    			"{\"vertical_id\": 1, \"silence_refunded_at\": \"2006-01-02T15:04:05.000Z07:00\"}",
    		),
    		textErrContain: "externalId required",
    	},
    	// tagID 19172 handler invalid context
    	{
    		name:           "no external id",
    		externalID:     "",
    		holdKey:        "cpa_123",
    		kind:           "write-off",
    		groupID:        gtc.String.ValueToPointer(uuid.New().String()),
    		status:         gtc.Int64.ValueToPointer(1),
    		context:        gtc.String.ValueToPointer("{\"vertical_id\": goods, \"silence_refunded_at\": \"вчера\"}"),
    		textErrContain: "externalId required",
    	},
    }
    
    for _, tt := range tests {
    	t.Run(tt.name, func(t *testing.T) {
    		t.Parallel()
    
    		ctx := context.Background()
    
    		h := stream_events_update.New(nil)
    		in := dto.StreamEventsUpdateIn{
    			ExternalID: tt.externalID,
    			HoldKey:    tt.holdKey,
    			Kind:       tt.kind,
    			GroupID:    tt.groupID,
    			Status:     tt.status,
    			Context:    tt.context,
    		}
    
    		out := dto.StreamEventsUpdateOut{}
    
    		err := h.Handle(ctx, &in, &out)
    		assert.Error(t, err)
    		assert.ErrorContains(t, err, tt.textErrContain)
    	})
    }
    

    }

    loop variable tt captured by func literalloopclosuredefault

    что за ошибка как решить?

  8. Assistant

    Ошибка, которую вы видите ("loop variable tt captured by func literalloopclosuredefault"), связана с тем, что в задание, выполняемое в рамках горутины, захватывается переменная цикла. В данном случае это переменная tt, которая используется в функции t.Run.

    Когда цикл завершает свое выполнение, переменная tt больше не изменяется, и если вы запускаете горутину для каждого теста с использованием tt, все тесты фактически используют последнее значение tt. Это приведет к тому, что ваша логика тестирования не будет работать как ожидается.

    Решение проблемы

    Чтобы избежать этой проблемы, вам нужно создать новую переменную в каждом итерации цикла, которая будет захвачена функцией в t.Run. Это можно сделать, создавая новую переменную и присваивая ей значение tt внутри цикла, как показано ниже:

    for _, tt := range tests {
    	t.Run(tt.name, func(t *testing.T) {
    		// Создаем локальную переменную для захвата текущего значения tt
    		ttCopy := tt
    
    		t.Parallel()
    
    		ctx := context.Background()
    
    		h := stream_events_update.New(nil)
    		in := dto.StreamEventsUpdateIn{
    			ExternalID: ttCopy.externalID,
    			HoldKey:    ttCopy.holdKey,
    			Kind:       ttCopy.kind,
    			GroupID:    ttCopy.groupID,
    			Status:     ttCopy.status,
    			Context:    ttCopy.context,
    		}
    
    		out := dto.StreamEventsUpdateOut{}
    
    		err := h.Handle(ctx, &in, &out)
    		assert.Error(t, err)
    		assert.ErrorContains(t, err, ttCopy.textErrContain)
    	})
    }
    

    В этом примере мы создаем новую переменную ttCopy, которая копирует текущее значение tt. Теперь каждый вызов t.Run будет использовать эту копию, и ошибка, связанная с захватом переменной цикла, исчезнет.

    Дополнительные советы

    • Если вы используете функции, которые могут выполняться параллельно (через t.Parallel), будьте осторожны с переменными, которые могут быть изменены другими горутинами. Лучше использовать локальные переменные, чтобы избежать подобных проблем.
    • Старайтесь избегать изменения общей состояния или переменных, которые могут быть захвачены во время работы горутин, так как это может привести к гонкам данных или другим ошибкам в многопоточных средах.