modelRT/handler/data_object_attribute_query_test.go

package handler

import (
	"context"
	"testing"

	"modelRT/common"
	"modelRT/constants"
	"modelRT/database"
	"modelRT/orm"

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

func TestValidateDataObjectField(t *testing.T) {
	tests := []struct {
		name           string
		token          string
		dataObjectType constants.DataObjectType
		field          string
		wantErr        error
	}{
		{name: "bay value", token: "nspath.component.bay.measurement", dataObjectType: constants.DataObjectTypeMeasurement, field: "value"},
		{name: "bay name", token: "nspath.component.bay.measurement", dataObjectType: constants.DataObjectTypeMeasurement, field: "name"},
		{name: "bay binding", token: "nspath.component.bay.measurement", dataObjectType: constants.DataObjectTypeMeasurement, field: "binding"},
		{name: "bay field is case insensitive", token: "nspath.component.bay.measurement", dataObjectType: constants.DataObjectTypeMeasurement, field: "DATA_SOURCE"},
		{name: "bay unsupported", token: "nspath.component.bay.measurement", dataObjectType: constants.DataObjectTypeMeasurement, field: "unknown", wantErr: common.ErrUnsupportedMeasurementField},
		{name: "parameter value", token: "nspath.component.rated.attribute", dataObjectType: constants.DataObjectTypeParameter, field: "value"},
		{name: "parameter mode", token: "nspath.component.rated.attribute", dataObjectType: constants.DataObjectTypeParameter, field: "mode"},
		{name: "parameter rejects name", token: "nspath.component.rated.attribute", dataObjectType: constants.DataObjectTypeParameter, field: "name", wantErr: common.ErrUnsupportedParameterField},
		{name: "component name", token: "nspath.component.component.name", dataObjectType: constants.DataObjectTypeParameter, field: "name"},
		{name: "component rejects mode", token: "nspath.component.component.name", dataObjectType: constants.DataObjectTypeParameter, field: "mode", wantErr: common.ErrUnsupportedParameterField},
		{name: "parameter rejects size", token: "nspath.component.rated.attribute", dataObjectType: constants.DataObjectTypeParameter, field: "size", wantErr: common.ErrUnsupportedParameterField},
		{name: "invalid type", token: "token", dataObjectType: constants.DataObjectType("unknown"), field: "value", wantErr: assert.AnError},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := validateDataObjectField(tt.token, tt.dataObjectType, tt.field)
			if tt.wantErr == nil {
				require.NoError(t, err)
				return
			}
			require.Error(t, err)
			if tt.wantErr != assert.AnError {
				assert.ErrorIs(t, err, tt.wantErr)
			}
		})
	}
}

func TestBuildParameterAttributeValue(t *testing.T) {
	parameter := &database.ParameterDataObject{
		Component: orm.Component{
			GridName:    "grid000",
			ZoneName:    "zone000",
			StationName: "station000",
			NSPath:      "110kV_TV",
			Tag:         "cable_22",
		},
		AttributeGroup: "rated",
		AttributeName:  "rated_voltage",
		AttributeType:  "DOUBLE PRECISION",
	}
	loader := func(_ context.Context, actual *database.ParameterDataObject) (any, error) {
		assert.Same(t, parameter, actual)
		return float64(220), nil
	}
	descriptionLoader := func(_ context.Context, attributeName string) (string, error) {
		assert.Equal(t, "rated_voltage", attributeName)
		return "额定电压", nil
	}

	tests := []struct {
		field    string
		expected any
	}{
		{field: "value", expected: float64(220)},
		{field: "meta", expected: "PARAM"},
		{field: "type", expected: "DOUBLE PRECISION"},
		{field: "name", expected: "110kV_TV.cable_22.rated.rated_voltage"},
		{field: "description", expected: "额定电压"},
		{field: "id", expected: "grid000.zone000.station000.110kV_TV.cable_22.rated.rated_voltage"},
	}

	for _, tt := range tests {
		t.Run(tt.field, func(t *testing.T) {
			actual, err := buildParameterAttributeValue(
				context.Background(),
				tt.field,
				parameter,
				loader,
				descriptionLoader,
			)
			require.NoError(t, err)
			assert.Equal(t, tt.expected, actual)
		})
	}
}

func TestBuildParameterAttributeValueRejectsUnsupportedField(t *testing.T) {
	_, err := buildParameterAttributeValue(
		context.Background(),
		"unknown",
		&database.ParameterDataObject{},
		nil,
		nil,
	)
	require.Error(t, err)
	assert.ErrorIs(t, err, common.ErrUnsupportedParameterField)
}

func TestBuildMeasurementAttributeValue(t *testing.T) {
	dataSource := orm.JSONMap{
		"type": float64(1),
		"io_address": map[string]any{
			"channel": "tm1p",
		},
	}
	eventPlan := orm.JSONMap{"enabled": true}
	binding := orm.JSONMap{"ct": map[string]any{"ratio": float64(2)}}
	measurement := &orm.Measurement{
		Tag:        "IA_rms",
		Name:       "A相电流",
		Mode:       1,
		Size:       10,
		DataSource: dataSource,
		EventPlan:  eventPlan,
		Binding:    binding,
	}
	component := &orm.Component{
		GridName:    "grid000",
		ZoneName:    "zone000",
		StationName: "station000",
		NSPath:      "110kV_TV",
		Tag:         "cable_22",
	}

	loader := func(_ context.Context, source orm.JSONMap) (any, error) {
		assert.Equal(t, dataSource, source)
		return float64(220), nil
	}

	tests := []struct {
		field    string
		expected any
	}{
		{field: "value", expected: float64(220)},
		{field: "mode", expected: true},
		{field: "meta", expected: "MEASUREMENT"},
		{field: "type", expected: "TM"},
		{field: "name", expected: "110kV_TV.IA_rms"},
		{field: "description", expected: "A相电流"},
		{field: "id", expected: "grid000.zone000.station000.110kV_TV.cable_22.bay.IA_rms"},
		{field: "size", expected: 10},
		{field: "data_source", expected: dataSource},
		{field: "event_plan", expected: eventPlan},
		{field: "binding", expected: binding},
	}

	for _, tt := range tests {
		t.Run(tt.field, func(t *testing.T) {
			actual, err := buildMeasurementAttributeValue(context.Background(), tt.field, measurement, component, loader)
			require.NoError(t, err)
			assert.Equal(t, tt.expected, actual)
		})
	}
}

func TestBuildMeasurementAttributeValueRejectsUnsupportedField(t *testing.T) {
	_, err := buildMeasurementAttributeValue(
		context.Background(),
		"unknown",
		&orm.Measurement{},
		&orm.Component{},
		nil,
	)
	require.Error(t, err)
	assert.ErrorIs(t, err, common.ErrUnsupportedMeasurementField)
}

func TestBuildMeasurementAttributeValueMode(t *testing.T) {
	component := &orm.Component{}

	manualMode, err := buildMeasurementAttributeValue(
		context.Background(),
		"mode",
		&orm.Measurement{Mode: 0},
		component,
		nil,
	)
	require.NoError(t, err)
	assert.Equal(t, false, manualMode)

	automaticMode, err := buildMeasurementAttributeValue(
		context.Background(),
		"mode",
		&orm.Measurement{Mode: 1},
		component,
		nil,
	)
	require.NoError(t, err)
	assert.Equal(t, true, automaticMode)

	_, err = buildMeasurementAttributeValue(
		context.Background(),
		"mode",
		&orm.Measurement{Mode: 2},
		component,
		nil,
	)
	require.Error(t, err)
	assert.Contains(t, err.Error(), "expected 0 or 1")
}