jwetzell/showbridge-go
1
0
Fork 0
mirror of https://github.com/jwetzell/showbridge-go.git synced 2026-09-08 14:48:59 +00:00
Code Issues Packages Projects Releases 10 Wiki Activity

expose config package

Browse Source
This commit is contained in:
Joel Wetzell
2026-09-07 18:43:11 -05:00
parent 176a42c7c1
commit a304b4b211
149 changed files with 150 additions and 145 deletions
Download Patch File Download Diff File Expand all files Collapse all files
config/api.go
+6
View File
@@ -0,0 +1,6 @@
package config
type ApiConfig struct {
Enabled bool `json:"enabled"`
Port int `json:"port"`
}
config/config.go
+12
View File
@@ -0,0 +1,12 @@
package config
type Config struct {
Api ApiConfig `json:"api"`
Modules []ModuleConfig `json:"modules"`
Routes []RouteConfig `json:"routes"`
}
type Configurable interface {
UpdateConfig(newConfig Config, triggerChangeChannel bool) ([]ModuleError, []RouteError, error)
GetRunningConfig() Config
}
config/module.go
+13
View File
@@ -0,0 +1,13 @@
package config
type ModuleConfig struct {
Id string `json:"id"`
Type string `json:"type"`
Params Params `json:"params,omitempty"`
}
type ModuleError struct {
Index int `json:"index"`
Config ModuleConfig `json:"config"`
Error string `json:"error"`
}
config/params.go
+145
View File
@@ -0,0 +1,145 @@
package config
import (
"errors"
"github.com/jwetzell/showbridge-go/internal/common"
)
type Params map[string]any
var (
ErrParamNotFound = errors.New("not found")
ErrParamNotString = errors.New("not a string")
ErrParamNotNumber = errors.New("not a number")
ErrParamNotInteger = errors.New("not an integer")
ErrParamNotBool = errors.New("not a boolean")
ErrParamNotSlice = errors.New("not a slice")
ErrParamNotStringSlice = errors.New("not a string slice")
ErrParamNotByteSlice = errors.New("not a byte slice")
ErrParamNotIntSlice = errors.New("not an int slice")
)
func (p Params) GetString(key string) (string, error) {
value, ok := p[key]
if !ok {
return "", ErrParamNotFound
}
stringValue, ok := value.(string)
if !ok {
return "", ErrParamNotString
}
return stringValue, nil
}
func (p Params) GetInt(key string) (int, error) {
value, ok := p[key]
if !ok {
return 0, ErrParamNotFound
}
intValue, ok := common.GetAnyAsInt(value)
if ok {
return intValue, nil
}
return 0, ErrParamNotNumber
}
func (p Params) GetFloat32(key string) (float32, error) {
value, ok := p[key]
if !ok {
return 0, ErrParamNotFound
}
floatValue, ok := common.GetAnyAsFloat32(value)
if ok {
return floatValue, nil
}
return 0, ErrParamNotNumber
}
func (p Params) GetFloat64(key string) (float64, error) {
value, ok := p[key]
if !ok {
return 0, ErrParamNotFound
}
floatValue, ok := common.GetAnyAsFloat64(value)
if ok {
return floatValue, nil
}
return 0, ErrParamNotNumber
}
func (p Params) GetBool(key string) (bool, error) {
value, ok := p[key]
if !ok {
return false, ErrParamNotFound
}
boolValue, ok := value.(bool)
if !ok {
return false, ErrParamNotBool
}
return boolValue, nil
}
func (p Params) GetStringSlice(key string) ([]string, error) {
value, ok := p[key]
if !ok {
return nil, ErrParamNotFound
}
alreadyStringSlice, ok := value.([]string)
if ok {
return alreadyStringSlice, nil
}
interfaceSlice, ok := value.([]any)
if !ok {
return nil, ErrParamNotSlice
}
stringSlice := make([]string, len(interfaceSlice))
for i, v := range interfaceSlice {
str, ok := v.(string)
if !ok {
return nil, ErrParamNotStringSlice
}
stringSlice[i] = str
}
return stringSlice, nil
}
func (p Params) GetIntSlice(key string) ([]int, error) {
value, ok := p[key]
if !ok {
return nil, ErrParamNotFound
}
intSlice, ok := common.GetAnyAsIntSlice(value)
if !ok {
return nil, ErrParamNotIntSlice
}
return intSlice, nil
}
func (p Params) GetByteSlice(key string) ([]byte, error) {
value, ok := p[key]
if !ok {
return nil, ErrParamNotFound
}
byteSlice, ok := common.GetAnyAsByteSlice(value)
if !ok {
return nil, ErrParamNotByteSlice
}
return byteSlice, nil
}
config/params_test.go
+628
View File
@@ -0,0 +1,628 @@
package config_test
import (
"encoding/json"
"errors"
"slices"
"testing"
"github.com/jwetzell/showbridge-go/config"
)
func TestGoodStringParamsJSON(t *testing.T) {
testCases := []struct {
name string
paramsJSON string
key string
expected string
}{
{
name: "string param",
paramsJSON: `{"key": "value"}`,
key: "key",
expected: "value",
},
}
for _, testCase := range testCases {
t.Run(testCase.name, func(t *testing.T) {
params := config.Params{}
err := json.Unmarshal([]byte(testCase.paramsJSON), &params)
if err != nil {
t.Fatalf("Failed to unmarshal params JSON: %v", err)
}
value, err := params.GetString(testCase.key)
if err != nil {
t.Fatalf("GetString returned error: %v", err)
}
if value != testCase.expected {
t.Fatalf("GetString got %s, expected %s", value, testCase.expected)
}
})
}
}
func TestBadStringParamsJSON(t *testing.T) {
testCases := []struct {
name string
paramsJSON string
key string
returnError error
}{
{
name: "key not found",
paramsJSON: `{"key": "value"}`,
key: "test",
returnError: config.ErrParamNotFound,
},
{
name: "not a string",
paramsJSON: `{"key": 1}`,
key: "key",
returnError: config.ErrParamNotString,
},
}
for _, testCase := range testCases {
t.Run(testCase.name, func(t *testing.T) {
params := config.Params{}
err := json.Unmarshal([]byte(testCase.paramsJSON), &params)
if err != nil {
t.Fatalf("Failed to unmarshal params JSON: %v", err)
}
value, err := params.GetString(testCase.key)
if err == nil {
t.Fatalf("GetString expected to fail but succeeded, got: %v", value)
}
if !errors.Is(err, testCase.returnError) {
t.Fatalf("GetString got error '%s', expected '%s'", err, testCase.returnError)
}
})
}
}
func TestGoodIntParamsJSON(t *testing.T) {
testCases := []struct {
name string
paramsJSON string
key string
expected int
}{
{
name: "int param",
paramsJSON: `{"key": 1}`,
key: "key",
expected: 1,
},
}
for _, testCase := range testCases {
t.Run(testCase.name, func(t *testing.T) {
params := config.Params{}
err := json.Unmarshal([]byte(testCase.paramsJSON), &params)
if err != nil {
t.Fatalf("Failed to unmarshal params JSON: %v", err)
}
value, err := params.GetInt(testCase.key)
if err != nil {
t.Fatalf("GetInt returned error: %v", err)
}
if value != testCase.expected {
t.Fatalf("GetInt got %d, expected %d", value, testCase.expected)
}
})
}
}
func TestBadIntParamsJSON(t *testing.T) {
testCases := []struct {
name string
paramsJSON string
key string
returnError error
}{
{
name: "key not found",
paramsJSON: `{"key": 1}`,
key: "test",
returnError: config.ErrParamNotFound,
},
{
name: "not a number",
paramsJSON: `{"key": "1"}`,
key: "key",
returnError: config.ErrParamNotNumber,
},
}
for _, testCase := range testCases {
t.Run(testCase.name, func(t *testing.T) {
params := config.Params{}
err := json.Unmarshal([]byte(testCase.paramsJSON), &params)
if err != nil {
t.Fatalf("Failed to unmarshal params JSON: %v", err)
}
value, err := params.GetInt(testCase.key)
if err == nil {
t.Fatalf("GetInt expected to fail but succeeded, got: %v", value)
}
if !errors.Is(err, testCase.returnError) {
t.Fatalf("GetInt got error '%s', expected '%s'", err, testCase.returnError)
}
})
}
}
func TestGoodFloat32ParamsJSON(t *testing.T) {
testCases := []struct {
name string
paramsJSON string
key string
expected float32
}{
{
name: "no decimal param",
paramsJSON: `{"key": 1}`,
key: "key",
expected: 1,
},
{
name: "float param",
paramsJSON: `{"key": 1.23}`,
key: "key",
expected: 1.23,
},
}
for _, testCase := range testCases {
t.Run(testCase.name, func(t *testing.T) {
params := config.Params{}
err := json.Unmarshal([]byte(testCase.paramsJSON), &params)
if err != nil {
t.Fatalf("Failed to unmarshal params JSON: %v", err)
}
value, err := params.GetFloat32(testCase.key)
if err != nil {
t.Fatalf("GetFloat32 returned error: %v", err)
}
if value != testCase.expected {
t.Fatalf("GetFloat32 got %f, expected %f", value, testCase.expected)
}
})
}
}
func TestBadFloat32ParamsJSON(t *testing.T) {
testCases := []struct {
name string
paramsJSON string
key string
returnError error
}{
{
name: "key not found",
paramsJSON: `{"key": 1}`,
key: "test",
returnError: config.ErrParamNotFound,
},
{
name: "not a number",
paramsJSON: `{"key": "1"}`,
key: "key",
returnError: config.ErrParamNotNumber,
},
}
for _, testCase := range testCases {
t.Run(testCase.name, func(t *testing.T) {
params := config.Params{}
err := json.Unmarshal([]byte(testCase.paramsJSON), &params)
if err != nil {
t.Fatalf("Failed to unmarshal params JSON: %v", err)
}
value, err := params.GetFloat32(testCase.key)
if err == nil {
t.Fatalf("GetFloat32 expected to fail but succeeded, got: %v", value)
}
if !errors.Is(err, testCase.returnError) {
t.Fatalf("GetFloat32 got error '%s', expected '%s'", err, testCase.returnError)
}
})
}
}
func TestGoodFloat64ParamsJSON(t *testing.T) {
testCases := []struct {
name string
paramsJSON string
key string
expected float64
}{
{
name: "no decimal param",
paramsJSON: `{"key": 1}`,
key: "key",
expected: 1,
},
{
name: "float param",
paramsJSON: `{"key": 1.23}`,
key: "key",
expected: 1.23,
},
}
for _, testCase := range testCases {
t.Run(testCase.name, func(t *testing.T) {
params := config.Params{}
err := json.Unmarshal([]byte(testCase.paramsJSON), &params)
if err != nil {
t.Fatalf("Failed to unmarshal params JSON: %v", err)
}
value, err := params.GetFloat64(testCase.key)
if err != nil {
t.Fatalf("GetFloat64 returned error: %v", err)
}
if value != testCase.expected {
t.Fatalf("GetFloat64 got %f, expected %f", value, testCase.expected)
}
})
}
}
func TestBadFloat64ParamsJSON(t *testing.T) {
testCases := []struct {
name string
paramsJSON string
key string
returnError error
}{
{
name: "key not found",
paramsJSON: `{"key": 1}`,
key: "test",
returnError: config.ErrParamNotFound,
},
{
name: "not a number",
paramsJSON: `{"key": "1"}`,
key: "key",
returnError: config.ErrParamNotNumber,
},
}
for _, testCase := range testCases {
t.Run(testCase.name, func(t *testing.T) {
params := config.Params{}
err := json.Unmarshal([]byte(testCase.paramsJSON), &params)
if err != nil {
t.Fatalf("Failed to unmarshal params JSON: %v", err)
}
value, err := params.GetFloat64(testCase.key)
if err == nil {
t.Fatalf("GetFloat64 expected to fail but succeeded, got: %v", value)
}
if !errors.Is(err, testCase.returnError) {
t.Fatalf("GetFloat64 got error '%s', expected '%s'", err, testCase.returnError)
}
})
}
}
func TestGoodBoolParamsJSON(t *testing.T) {
testCases := []struct {
name string
paramsJSON string
key string
expected bool
}{
{
name: "bool param",
paramsJSON: `{"key": true}`,
key: "key",
expected: true,
},
}
for _, testCase := range testCases {
t.Run(testCase.name, func(t *testing.T) {
params := config.Params{}
err := json.Unmarshal([]byte(testCase.paramsJSON), &params)
if err != nil {
t.Fatalf("Failed to unmarshal params JSON: %v", err)
}
value, err := params.GetBool(testCase.key)
if err != nil {
t.Fatalf("GetBool returned error: %v", err)
}
if value != testCase.expected {
t.Fatalf("GetBool got %t, expected %t", value, testCase.expected)
}
})
}
}
func TestBadBoolParamsJSON(t *testing.T) {
testCases := []struct {
name string
paramsJSON string
key string
returnError error
}{
{
name: "key not found",
paramsJSON: `{"key": 1}`,
key: "test",
returnError: config.ErrParamNotFound,
},
{
name: "not a bool",
paramsJSON: `{"key": "1"}`,
key: "key",
returnError: config.ErrParamNotBool,
},
}
for _, testCase := range testCases {
t.Run(testCase.name, func(t *testing.T) {
params := config.Params{}
err := json.Unmarshal([]byte(testCase.paramsJSON), &params)
if err != nil {
t.Fatalf("Failed to unmarshal params JSON: %v", err)
}
value, err := params.GetBool(testCase.key)
if err == nil {
t.Fatalf("GetBool expected to fail but succeeded, got: %v", value)
}
if !errors.Is(err, testCase.returnError) {
t.Fatalf("GetBool got error '%s', expected '%s'", err, testCase.returnError)
}
})
}
}
func TestGoodStringSliceParamsJSON(t *testing.T) {
testCases := []struct {
name string
paramsJSON string
key string
expected []string
}{
{
name: "string array",
paramsJSON: `{"key": ["value1", "value2"]}`,
key: "key",
expected: []string{"value1", "value2"},
},
}
for _, testCase := range testCases {
t.Run(testCase.name, func(t *testing.T) {
params := config.Params{}
err := json.Unmarshal([]byte(testCase.paramsJSON), &params)
if err != nil {
t.Fatalf("Failed to unmarshal params JSON: %v", err)
}
value, err := params.GetStringSlice(testCase.key)
if err != nil {
t.Fatalf("GetStringSlice returned error: %v", err)
}
if !slices.Equal(value, testCase.expected) {
t.Fatalf("GetStringSlice got %v, expected %v", value, testCase.expected)
}
})
}
}
func TestBadStringSliceParamsJSON(t *testing.T) {
testCases := []struct {
name string
paramsJSON string
key string
returnError error
}{
{
name: "key not found",
paramsJSON: `{"key": ["value1", "value2"]}`,
key: "test",
returnError: config.ErrParamNotFound,
},
{
name: "not a slice",
paramsJSON: `{"key": "value"}`,
key: "key",
returnError: config.ErrParamNotSlice,
},
{
name: "not a string slice",
paramsJSON: `{"key": ["value1", 2]}`,
key: "key",
returnError: config.ErrParamNotStringSlice,
},
}
for _, testCase := range testCases {
t.Run(testCase.name, func(t *testing.T) {
params := config.Params{}
err := json.Unmarshal([]byte(testCase.paramsJSON), &params)
if err != nil {
t.Fatalf("Failed to unmarshal params JSON: %v", err)
}
value, err := params.GetStringSlice(testCase.key)
if err == nil {
t.Fatalf("GetStringSlice expected to fail but succeeded, got: %v", value)
}
if !errors.Is(err, testCase.returnError) {
t.Fatalf("GetStringSlice got error '%s', expected '%s'", err, testCase.returnError)
}
})
}
}
func TestGoodIntSliceParamsJSON(t *testing.T) {
testCases := []struct {
name string
paramsJSON string
key string
expected []int
}{
{
name: "int array",
paramsJSON: `{"key": [1, 2, 3]}`,
key: "key",
expected: []int{1, 2, 3},
},
{
name: "int array with floats",
paramsJSON: `{"key": [1.0, 2.0, 3.0]}`,
key: "key",
expected: []int{1, 2, 3},
},
}
for _, testCase := range testCases {
t.Run(testCase.name, func(t *testing.T) {
params := config.Params{}
err := json.Unmarshal([]byte(testCase.paramsJSON), &params)
if err != nil {
t.Fatalf("Failed to unmarshal params JSON: %v", err)
}
value, err := params.GetIntSlice(testCase.key)
if err != nil {
t.Fatalf("GetIntSlice returned error: %v", err)
}
if !slices.Equal(value, testCase.expected) {
t.Fatalf("GetIntSlice got %v, expected %v", value, testCase.expected)
}
})
}
}
func TestBadIntSliceParamsJSON(t *testing.T) {
testCases := []struct {
name string
paramsJSON string
key string
returnError error
}{
{
name: "key not found",
paramsJSON: `{"key": ["value1", "value2"]}`,
key: "test",
returnError: config.ErrParamNotFound,
},
{
name: "not a slice",
paramsJSON: `{"key": "value"}`,
key: "key",
returnError: config.ErrParamNotIntSlice,
},
{
name: "not a int slice",
paramsJSON: `{"key": ["value1", 2]}`,
key: "key",
returnError: config.ErrParamNotIntSlice,
},
}
for _, testCase := range testCases {
t.Run(testCase.name, func(t *testing.T) {
params := config.Params{}
err := json.Unmarshal([]byte(testCase.paramsJSON), &params)
if err != nil {
t.Fatalf("Failed to unmarshal params JSON: %v", err)
}
value, err := params.GetIntSlice(testCase.key)
if err == nil {
t.Fatalf("GetIntSlice expected to fail but succeeded, got: %v", value)
}
if !errors.Is(err, testCase.returnError) {
t.Fatalf("GetIntSlice got error '%s', expected '%s'", err, testCase.returnError)
}
})
}
}
func TestGoodByteSliceParamsJSON(t *testing.T) {
testCases := []struct {
name string
paramsJSON string
key string
expected []byte
}{
{
name: "byte array",
paramsJSON: `{"key": [1,2,3,4]}`,
key: "key",
expected: []byte{1, 2, 3, 4},
},
{
name: "byte array with floats",
paramsJSON: `{"key": [1.0,2.0,3.0,4.0]}`,
key: "key",
expected: []byte{1, 2, 3, 4},
},
}
for _, testCase := range testCases {
t.Run(testCase.name, func(t *testing.T) {
params := config.Params{}
err := json.Unmarshal([]byte(testCase.paramsJSON), &params)
if err != nil {
t.Fatalf("Failed to unmarshal params JSON: %v", err)
}
value, err := params.GetByteSlice(testCase.key)
if err != nil {
t.Fatalf("GetByteSlice returned error: %v", err)
}
if !slices.Equal(value, testCase.expected) {
t.Fatalf("GetByteSlice got %v, expected %v", value, testCase.expected)
}
})
}
}
func TestBadByteSliceParamsJSON(t *testing.T) {
testCases := []struct {
name string
paramsJSON string
key string
returnError error
}{
{
name: "key not found",
paramsJSON: `{"key": ["value1", "value2"]}`,
key: "test",
returnError: config.ErrParamNotFound,
},
{
name: "not a slice",
paramsJSON: `{"key": "value"}`,
key: "key",
returnError: config.ErrParamNotByteSlice,
},
{
name: "not a int slice",
paramsJSON: `{"key": ["value1", 2]}`,
key: "key",
returnError: config.ErrParamNotByteSlice,
},
}
for _, testCase := range testCases {
t.Run(testCase.name, func(t *testing.T) {
params := config.Params{}
err := json.Unmarshal([]byte(testCase.paramsJSON), &params)
if err != nil {
t.Fatalf("Failed to unmarshal params JSON: %v", err)
}
value, err := params.GetByteSlice(testCase.key)
if err == nil {
t.Fatalf("GetByteSlice expected to fail but succeeded, got: %v", value)
}
if !errors.Is(err, testCase.returnError) {
t.Fatalf("GetByteSlice got error '%s', expected '%s'", err, testCase.returnError)
}
})
}
}
config/processor.go
+7
View File
@@ -0,0 +1,7 @@
package config
type ProcessorConfig struct {
Id string `json:"id"`
Type string `json:"type"`
Params Params `json:"params,omitempty"`
}
config/route.go
+13
View File
@@ -0,0 +1,13 @@
package config
type RouteConfig struct {
Id string `json:"id"`
Input string `json:"input"`
Processors []ProcessorConfig `json:"processors"`
}
type RouteError struct {
Index int `json:"index"`
Config RouteConfig `json:"config"`
Error string `json:"error"`
}