backup/showbridge-go
1
0
Fork 0
mirror of https://github.com/jwetzell/showbridge-go.git synced 2026-04-26 21:05:30 +00:00
Code Issues Packages Projects Releases Wiki Activity

remove uint parse and random

Browse Source
This commit is contained in:
Joel Wetzell
2026-03-03 21:42:08 -06:00
parent c25a36f09c
commit 7ac0ec7582
5 changed files with 0 additions and 514 deletions
Download Patch File Download Diff File Expand all files Collapse all files

171
internal/processor/test/uint-parse_test.go
View File

@@ -1,171 +0,0 @@
package processor_test
import (
"testing"
"github.com/jwetzell/showbridge-go/internal/config"
"github.com/jwetzell/showbridge-go/internal/processor"
)
func TestUintParseFromRegistry(t *testing.T) {
registration, ok := processor.ProcessorRegistry["uint.parse"]
if !ok {
t.Fatalf("uint.parse processor not registered")
}
processorInstance, err := registration.New(config.ProcessorConfig{
Type: "uint.parse",
})
if err != nil {
t.Fatalf("failed to create uint.parse processor: %s", err)
}
if processorInstance.Type() != "uint.parse" {
t.Fatalf("uint.parse processor has wrong type: %s", processorInstance.Type())
}
}
func TestGoodUintParse(t *testing.T) {
tests := []struct {
name string
params map[string]any
payload any
expected uint64
}{
{
name: "positive number",
params: map[string]any{"base": 10, "bitSize": 64},
payload: "12345",
expected: 12345,
},
{
name: "zero",
params: map[string]any{"base": 10, "bitSize": 64},
payload: "0",
expected: 0,
},
{
name: "binary",
params: map[string]any{"base": 2, "bitSize": 64},
payload: "1010101",
expected: 85,
},
{
name: "hex",
params: map[string]any{"base": 16, "bitSize": 64},
payload: "15F",
expected: 351,
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
registration, ok := processor.ProcessorRegistry["uint.parse"]
if !ok {
t.Fatalf("uint.parse processor not registered")
}
processorInstance, err := registration.New(config.ProcessorConfig{
Type: "uint.parse",
Params: test.params,
})
if err != nil {
t.Fatalf("uint.parse failed to create processor: %s", err)
}
got, err := processorInstance.Process(t.Context(), test.payload)
if err != nil {
t.Fatalf("uint.parse processing failed: %s", err)
}
gotUint, ok := got.(uint64)
if !ok {
t.Fatalf("uint.parse returned a %T payload: %s", got, got)
}
if gotUint != test.expected {
t.Fatalf("uint.parse got %d, expected %d", gotUint, test.expected)
}
})
}
}
func TestBadUintParse(t *testing.T) {
tests := []struct {
name string
params map[string]any
payload any
errorString string
}{
{
name: "non-string base",
params: map[string]any{
"base": "10",
"bitSize": 64,
},
payload: "12345",
errorString: "uint.parse base error: not a number",
},
{
name: "non-string bitSize",
params: map[string]any{
"base": 10,
"bitSize": "64",
},
payload: "12345",
errorString: "uint.parse bitSize error: not a number",
},
{
name: "non-string input",
params: map[string]any{"base": 10, "bitSize": 64},
payload: []byte{0x01},
errorString: "uint.parse processor only accepts a string",
},
{
name: "not uint string",
params: map[string]any{"base": 10, "bitSize": 64},
payload: "-1234",
errorString: "strconv.ParseUint: parsing \"-1234\": invalid syntax",
},
{
name: "bit overflow",
params: map[string]any{"base": 10, "bitSize": 32},
payload: "123456789012345678901234567",
errorString: "strconv.ParseUint: parsing \"123456789012345678901234567\": value out of range",
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
registration, ok := processor.ProcessorRegistry["uint.parse"]
if !ok {
t.Fatalf("uint.parse processor not registered")
}
processorInstance, err := registration.New(config.ProcessorConfig{
Type: "uint.parse",
Params: test.params,
})
if err != nil {
if err.Error() != test.errorString {
t.Fatalf("uint.parse got error '%s', expected '%s'", err.Error(), test.errorString)
}
return
}
got, err := processorInstance.Process(t.Context(), test.payload)
if err == nil {
t.Fatalf("uint.parse expected to fail but succeeded, got: %v", got)
}
if err.Error() != test.errorString {
t.Fatalf("uint.parse got error '%s', expected '%s'", err.Error(), test.errorString)
}
})
}
}

193
internal/processor/test/uint-random_test.go
View File

@@ -1,193 +0,0 @@
package processor_test
import (
"testing"
"github.com/jwetzell/showbridge-go/internal/config"
"github.com/jwetzell/showbridge-go/internal/processor"
)
func TestUintRandomFromRegistry(t *testing.T) {
registration, ok := processor.ProcessorRegistry["uint.random"]
if !ok {
t.Fatalf("uint.random processor not registered")
}
processorInstance, err := registration.New(config.ProcessorConfig{
Type: "uint.random",
Params: map[string]any{
"min": 1,
"max": 10,
},
})
if err != nil {
t.Fatalf("failed to create uint.random processor: %s", err)
}
if processorInstance.Type() != "uint.random" {
t.Fatalf("uint.random processor has wrong type: %s", processorInstance.Type())
}
}
func TestUintRandomGoodConfig(t *testing.T) {
registration, ok := processor.ProcessorRegistry["uint.random"]
if !ok {
t.Fatalf("uint.random processor not registered")
}
processorInstance, err := registration.New(config.ProcessorConfig{
Type: "uint.random",
Params: map[string]any{
"min": 1,
"max": 10,
},
})
if err != nil {
t.Fatalf("uint.random should have created processor but got error: %s", err)
}
payload := "12345"
got, err := processorInstance.Process(t.Context(), payload)
if err != nil {
t.Fatalf("uint.random processing failed: %s", err)
}
gotUint, ok := got.(uint)
if !ok {
t.Fatalf("uint.random returned a %T payload: %s", got, got)
}
if gotUint < 1 || gotUint > 10 {
t.Fatalf("uint.random got %d, expected between %d and %d", gotUint, 1, 10)
}
}
func TestGoodUintRandom(t *testing.T) {
tests := []struct {
name string
params map[string]any
payload any
}{
{
name: "1-10",
params: map[string]any{"min": 1, "max": 10},
payload: "12345",
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
registration, ok := processor.ProcessorRegistry["uint.random"]
if !ok {
t.Fatalf("uint.random processor not registered")
}
processorInstance, err := registration.New(config.ProcessorConfig{
Type: "uint.random",
Params: test.params,
})
if err != nil {
t.Fatalf("uint.random failed to create processor: %s", err)
}
got, err := processorInstance.Process(t.Context(), test.payload)
if err != nil {
t.Fatalf("uint.random processing failed: %s", err)
}
gotUint, ok := got.(uint)
if !ok {
t.Fatalf("uint.random returned a %T payload: %s", got, got)
}
minNum, ok := test.params["min"].(int)
if !ok {
t.Fatalf("uint.random test min param is not a number")
}
maxNum, ok := test.params["max"].(int)
if !ok {
t.Fatalf("uint.random test max param is not a number")
}
if gotUint < uint(minNum) || gotUint > uint(maxNum) {
t.Fatalf("uint.random got %d, expected between %d and %d", gotUint, uint(minNum), uint(maxNum))
}
})
}
}
func TestBadUintRandom(t *testing.T) {
tests := []struct {
name string
params map[string]any
payload any
errorString string
}{
{
name: "no min param",
payload: "hello",
params: map[string]any{"max": 10},
errorString: "uint.random min error: not found",
},
{
name: "no max param",
payload: "hello",
params: map[string]any{"min": 1},
errorString: "uint.random max error: not found",
},
{
name: "min param not a number",
payload: "hello",
params: map[string]any{"min": "1", "max": 10},
errorString: "uint.random min error: not a number",
},
{
name: "max param not a number",
payload: "hello",
params: map[string]any{"min": 1, "max": "10"},
errorString: "uint.random max error: not a number",
},
{
name: "max less than min",
payload: "hello",
params: map[string]any{"min": 1, "max": 0},
errorString: "uint.random max must be greater than min",
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
registration, ok := processor.ProcessorRegistry["uint.random"]
if !ok {
t.Fatalf("uint.random processor not registered")
}
processorInstance, err := registration.New(config.ProcessorConfig{
Type: "uint.random",
Params: test.params,
})
if err != nil {
if test.errorString != err.Error() {
t.Fatalf("uint.random got error '%s', expected '%s'", err.Error(), test.errorString)
}
return
}
got, err := processorInstance.Process(t.Context(), test.payload)
if err == nil {
t.Fatalf("uint.random expected to fail but got payload: %s", got)
}
if err.Error() != test.errorString {
t.Fatalf("uint.random got error '%s', expected '%s'", err.Error(), test.errorString)
}
})
}
}