httprunner/uixt/option/action_test.go

package option

import (
	"testing"

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

func TestUnifiedActionRequest_Options(t *testing.T) {
	// Test TapXY request conversion
	unifiedReq := &ActionOptions{
		Platform:      "android",
		Serial:        "device123",
		X:             0.5,
		Y:             0.7,
		Duration:      1.0,
		MaxRetryTimes: 3,
		ScreenOptions: ScreenOptions{
			ScreenFilterOptions: ScreenFilterOptions{
				Regex: true,
			},
		},
	}

	actionOpts := unifiedReq.Options()

	assert.Equal(t, 1.0, unifiedReq.Duration)
	assert.Equal(t, 3, unifiedReq.MaxRetryTimes)
	assert.True(t, unifiedReq.Regex)
	assert.NotEmpty(t, actionOpts)
}

func TestUnifiedActionRequest_GetMCPOptions(t *testing.T) {
	unifiedReq := &ActionOptions{
		Platform: "android",
		Serial:   "device123",
	}

	// Test TapXY options
	tapOptions := unifiedReq.GetMCPOptions(ACTION_TapXY)
	assert.NotEmpty(t, tapOptions)

	// Test TapByOCR options
	ocrOptions := unifiedReq.GetMCPOptions(ACTION_TapByOCR)
	assert.NotEmpty(t, ocrOptions)

	// Test unknown action (should return empty options)
	unknownOptions := unifiedReq.GetMCPOptions("unknown_action")
	assert.Empty(t, unknownOptions)
}

func TestUnifiedActionRequest_SwipeDirection(t *testing.T) {
	unifiedReq := &ActionOptions{
		Platform:      "android",
		Serial:        "device123",
		Direction:     "up",
		Duration:      2.0,
		PressDuration: 0.5,
	}

	opts := unifiedReq.Options()
	assert.Equal(t, "up", unifiedReq.Direction)
	assert.Equal(t, 2.0, unifiedReq.Duration)
	assert.Equal(t, 0.5, unifiedReq.PressDuration)
	assert.NotEmpty(t, opts)
}

func TestUnifiedActionRequest_SwipeCoordinate(t *testing.T) {
	params := []float64{0.2, 0.8, 0.2, 0.2}

	unifiedReq := &ActionOptions{
		Platform:  "android",
		Serial:    "device123",
		Direction: params,
	}

	opts := unifiedReq.Options()
	assert.Equal(t, params, unifiedReq.Direction)
	assert.NotEmpty(t, opts)
}

func TestUnifiedActionRequest_ScreenOptions(t *testing.T) {
	uiTypes := []string{"button", "text"}

	unifiedReq := &ActionOptions{
		Platform: "android",
		Serial:   "device123",
		ScreenOptions: ScreenOptions{
			ScreenShotOptions: ScreenShotOptions{
				ScreenShotWithOCR:     true,
				ScreenShotWithUpload:  true,
				ScreenShotWithUITypes: uiTypes,
			},
		},
	}

	opts := unifiedReq.Options()
	assert.True(t, unifiedReq.ScreenShotWithOCR)
	assert.True(t, unifiedReq.ScreenShotWithUpload)
	assert.Equal(t, uiTypes, unifiedReq.ScreenShotWithUITypes)
	assert.NotEmpty(t, opts)
}

func TestUnifiedActionRequest_NilPointerSafety(t *testing.T) {
	// Test with nil pointers
	unifiedReq := &ActionOptions{
		Platform: "android",
		Serial:   "device123",
		// All pointer fields are nil
	}

	opts := unifiedReq.Options()
	assert.Equal(t, 0, unifiedReq.MaxRetryTimes)
	assert.Equal(t, 0.0, unifiedReq.Duration)
	assert.Equal(t, 0.0, unifiedReq.PressDuration)
	assert.False(t, unifiedReq.Regex)
	assert.False(t, unifiedReq.TapRandomRect)
	// When all fields are default values, Options() may return empty slice
	// This is expected behavior
	assert.NotNil(t, opts)
}

func TestUnifiedActionRequest_CustomOptions(t *testing.T) {
	customData := map[string]interface{}{
		"custom_key": "custom_value",
		"number":     42,
	}

	unifiedReq := &ActionOptions{
		Platform: "android",
		Serial:   "device123",
		Custom:   customData,
	}

	opts := unifiedReq.Options()
	assert.Equal(t, customData, unifiedReq.Custom)
	assert.NotEmpty(t, opts)
}

func TestUnifiedActionRequest_BasicTypeFields(t *testing.T) {
	// Test basic type fields (no longer pointers)
	unifiedReq := &ActionOptions{
		Platform:     "android",
		Serial:       "device123",
		Count:        5,
		Keycode:      123,
		Delta:        10,
		Width:        800,
		Height:       600,
		Seconds:      2.5,
		Milliseconds: 1500,
		TabIndex:     3,
	}

	// Test direct field access (no need for Getter methods)
	assert.Equal(t, 5, unifiedReq.Count)
	assert.Equal(t, 123, unifiedReq.Keycode)
	assert.Equal(t, 10, unifiedReq.Delta)
	assert.Equal(t, 800, unifiedReq.Width)
	assert.Equal(t, 600, unifiedReq.Height)
	assert.Equal(t, 2.5, unifiedReq.Seconds)
	assert.Equal(t, int64(1500), unifiedReq.Milliseconds)
	assert.Equal(t, 3, unifiedReq.TabIndex)

	// Test zero value detection
	emptyReq := &ActionOptions{}
	assert.Equal(t, 0, emptyReq.Count)
	assert.Equal(t, 0, emptyReq.Keycode)
	assert.Equal(t, 0, emptyReq.Delta)
	assert.Equal(t, 0, emptyReq.Width)
	assert.Equal(t, 0, emptyReq.Height)
	assert.Equal(t, 0.0, emptyReq.Seconds)
	assert.Equal(t, int64(0), emptyReq.Milliseconds)
	assert.Equal(t, 0, emptyReq.TabIndex)
}