voicecode_test.go

// Copyright 2017-2026 Allow2 Pty Ltd. All rights reserved.
// Use of this source code is governed by the Allow2 API and SDK Licence.

package allow2service

import (
	"testing"
)

func TestGenerateVoiceChallenge(t *testing.T) {
	secret := "test-secret-key"
	date := "2026-03-12"

	pair, err := GenerateVoiceChallenge(secret, RequestTypeMoreTime, 3, 30, date)
	if err != nil {
		t.Fatalf("GenerateVoiceChallenge returned error: %v", err)
	}

	if pair.Challenge == "" {
		t.Fatal("Challenge should not be empty")
	}

	if pair.ExpectedResponse == "" {
		t.Fatal("ExpectedResponse should not be empty")
	}

	if len(pair.ExpectedResponse) != 6 {
		t.Fatalf("ExpectedResponse should be 6 digits, got %d: %q", len(pair.ExpectedResponse), pair.ExpectedResponse)
	}

	// Verify the response matches
	valid := VerifyVoiceResponse(secret, pair.Challenge, pair.ExpectedResponse, date)
	if !valid {
		t.Fatal("VerifyVoiceResponse should return true for generated pair")
	}
}

func TestVerifyVoiceResponse_InvalidResponse(t *testing.T) {
	secret := "test-secret-key"
	date := "2026-03-12"

	pair, err := GenerateVoiceChallenge(secret, RequestTypeBanLift, 6, 0, date)
	if err != nil {
		t.Fatalf("GenerateVoiceChallenge returned error: %v", err)
	}

	// Wrong response code
	valid := VerifyVoiceResponse(secret, pair.Challenge, "000000", date)
	if pair.ExpectedResponse != "000000" && valid {
		t.Fatal("VerifyVoiceResponse should return false for wrong response")
	}
}

func TestVerifyVoiceResponse_WrongSecret(t *testing.T) {
	date := "2026-03-12"

	pair, err := GenerateVoiceChallenge("secret-a", RequestTypeMoreTime, 1, 15, date)
	if err != nil {
		t.Fatalf("GenerateVoiceChallenge returned error: %v", err)
	}

	// Verify with different secret should fail
	valid := VerifyVoiceResponse("secret-b", pair.Challenge, pair.ExpectedResponse, date)
	if valid {
		t.Fatal("VerifyVoiceResponse should return false when using different secret")
	}
}

func TestVerifyVoiceResponse_WrongDate(t *testing.T) {
	secret := "test-secret-key"

	pair, err := GenerateVoiceChallenge(secret, RequestTypeDayTypeChange, 1, 0, "2026-03-12")
	if err != nil {
		t.Fatalf("GenerateVoiceChallenge returned error: %v", err)
	}

	// Verify with different date should fail (date-bound)
	valid := VerifyVoiceResponse(secret, pair.Challenge, pair.ExpectedResponse, "2026-03-13")
	if valid {
		t.Fatal("VerifyVoiceResponse should return false for different date")
	}
}

func TestVerifyVoiceResponse_Deterministic(t *testing.T) {
	secret := "deterministic-test"
	challenge := "0 03 06 42"
	date := "2026-01-01"

	response1 := computeResponse(secret, challenge, date)
	response2 := computeResponse(secret, challenge, date)

	if response1 != response2 {
		t.Fatalf("computeResponse should be deterministic: %q != %q", response1, response2)
	}

	if len(response1) != 6 {
		t.Fatalf("Response should be 6 digits, got %d: %q", len(response1), response1)
	}
}

func TestDecodeChallenge(t *testing.T) {
	tests := []struct {
		name      string
		challenge string
		wantNil   bool
		wantType  int
		wantAct   int
		wantMin   int
		wantNonce int
	}{
		{
			name:      "valid more time",
			challenge: "0 03 06 42",
			wantType:  0,
			wantAct:   3,
			wantMin:   30,
			wantNonce: 42,
		},
		{
			name:      "valid day type change",
			challenge: "1 01 00 99",
			wantType:  1,
			wantAct:   1,
			wantMin:   0,
			wantNonce: 99,
		},
		{
			name:      "valid ban lift",
			challenge: "2 06 00 05",
			wantType:  2,
			wantAct:   6,
			wantMin:   0,
			wantNonce: 5,
		},
		{
			name:    "empty string",
			wantNil: true,
		},
		{
			name:      "only 3 parts",
			challenge: "0 03 06",
			wantNil:   true,
		},
		{
			name:      "5 parts",
			challenge: "0 03 06 42 99",
			wantNil:   true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			decoded := DecodeChallenge(tt.challenge)
			if tt.wantNil {
				if decoded != nil {
					t.Fatal("Expected nil, got decoded challenge")
				}
				return
			}
			if decoded == nil {
				t.Fatal("Expected decoded challenge, got nil")
			}
			if decoded.Type != tt.wantType {
				t.Errorf("Type = %d, want %d", decoded.Type, tt.wantType)
			}
			if decoded.ActivityID != tt.wantAct {
				t.Errorf("ActivityID = %d, want %d", decoded.ActivityID, tt.wantAct)
			}
			if decoded.Minutes != tt.wantMin {
				t.Errorf("Minutes = %d, want %d", decoded.Minutes, tt.wantMin)
			}
			if decoded.Nonce != tt.wantNonce {
				t.Errorf("Nonce = %d, want %d", decoded.Nonce, tt.wantNonce)
			}
		})
	}
}

func TestGenerateVoiceChallenge_ClampValues(t *testing.T) {
	secret := "test"
	date := "2026-01-01"

	// Activity ID > 99 should be clamped
	pair, err := GenerateVoiceChallenge(secret, RequestTypeMoreTime, 150, 0, date)
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	decoded := DecodeChallenge(pair.Challenge)
	if decoded == nil {
		t.Fatal("Failed to decode challenge")
	}
	if decoded.ActivityID > 99 {
		t.Errorf("Activity ID should be clamped to 99, got %d", decoded.ActivityID)
	}

	// Minutes > 495 should be clamped (99 * 5 = 495)
	pair, err = GenerateVoiceChallenge(secret, RequestTypeMoreTime, 1, 600, date)
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	decoded = DecodeChallenge(pair.Challenge)
	if decoded == nil {
		t.Fatal("Failed to decode challenge")
	}
	if decoded.Minutes > 495 {
		t.Errorf("Minutes should be clamped to 495, got %d", decoded.Minutes)
	}
}

func TestRequestTypeVoiceCodes(t *testing.T) {
	tests := []struct {
		rt       RequestType
		wantCode int
	}{
		{RequestTypeMoreTime, 0},
		{RequestTypeDayTypeChange, 1},
		{RequestTypeBanLift, 2},
	}

	for _, tt := range tests {
		if got := tt.rt.VoiceCode(); got != tt.wantCode {
			t.Errorf("%s.VoiceCode() = %d, want %d", tt.rt, got, tt.wantCode)
		}
	}
}