LukeParke/libopenapi
1
0
Fork 0
mirror of https://github.com/LukeHagar/libopenapi.git synced 2025-12-07 04:20:14 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
77ecbd418f5ee871e425d3a87daa1bb64ead2ec7
libopenapi/utils/utils_test.go
Dave Shanley 77ecbd418f Updated model builder to use lowercase checks only. **breaking change** 
The case checking seems kinda dumb now looking back at this code. I am not sure why I felt the need to do that, however after being aware of it for some time and not being happy with the extra cycles it puts the code through.

This change removes ConvertCase from the utils package, as it's no longer used or needed right now. If it needs co come back, we can re-add the code, but deleting code always makes me happy.
It also removed a dependency from the project, which reduces the footprint, great!
2022-11-18 11:00:34 -05:00

668 lines
16 KiB
Go
Raw Blame History

package utils
import (
"github.com/stretchr/testify/assert"
"gopkg.in/yaml.v3"
"io/ioutil"
"sync"
"testing"
)
type petstore []byte
var once sync.Once
var (
psBytes petstore
)
func getPetstore() petstore {
once.Do(func() {
psBytes, _ = ioutil.ReadFile("../test_specs/petstorev3.json")
})
return psBytes
}
func TestRenderCodeSnippet(t *testing.T) {
code := []string{"hey", "ho", "let's", "go!"}
startNode := &yaml.Node{
Line: 1,
}
rendered := RenderCodeSnippet(startNode, code, 1, 3)
assert.Equal(t, "hey\nho\nlet's\n", rendered)
}
func TestRenderCodeSnippet_BelowStart(t *testing.T) {
code := []string{"hey", "ho", "let's", "go!"}
startNode := &yaml.Node{
Line: 0,
}
rendered := RenderCodeSnippet(startNode, code, 1, 3)
assert.Equal(t, "hey\nho\nlet's\n", rendered)
}
func TestFindNodes(t *testing.T) {
nodes, err := FindNodes(getPetstore(), "$.info.contact")
assert.NoError(t, err)
assert.NotNil(t, nodes)
assert.Len(t, nodes, 1)
}
func TestFindNodes_BadPath(t *testing.T) {
nodes, err := FindNodes(getPetstore(), "I am not valid")
assert.Error(t, err)
assert.Nil(t, nodes)
}
func TestFindLastChildNode(t *testing.T) {
nodes, _ := FindNodes(getPetstore(), "$.info")
lastNode := FindLastChildNode(nodes[0])
assert.Equal(t, "1.0.11", lastNode.Value) // should be the version.
}
func TestFindLastChildNode_WithKids(t *testing.T) {
nodes, _ := FindNodes(getPetstore(), "$.paths./pet")
lastNode := FindLastChildNode(nodes[0])
assert.Equal(t, "read:pets", lastNode.Value)
}
func TestFindLastChildNode_NotFound(t *testing.T) {
node := &yaml.Node{
Value: "same",
}
lastNode := FindLastChildNode(node)
assert.Equal(t, "same", lastNode.Value) // should be the same node
}
func TestBuildPath(t *testing.T) {
assert.Equal(t, "$.fresh.fish.and.chicken.nuggets",
BuildPath("$.fresh.fish", []string{"and", "chicken", "nuggets"}))
}
func TestBuildPath_WithTrailingPeriod(t *testing.T) {
assert.Equal(t, "$.fresh.fish.and.chicken.nuggets",
BuildPath("$.fresh.fish", []string{"and", "chicken", "nuggets", ""}))
}
func TestFindNodesWithoutDeserializing(t *testing.T) {
root, _ := FindNodes(getPetstore(), "$")
nodes, err := FindNodesWithoutDeserializing(root[0], "$.info.contact")
assert.NoError(t, err)
assert.NotNil(t, nodes)
assert.Len(t, nodes, 1)
}
func TestFindNodesWithoutDeserializing_InvalidPath(t *testing.T) {
root, _ := FindNodes(getPetstore(), "$")
nodes, err := FindNodesWithoutDeserializing(root[0], "I love a good curry")
assert.Error(t, err)
assert.Nil(t, nodes)
}
func TestConvertInterfaceIntoStringMap(t *testing.T) {
var d interface{}
n := make(map[string]string)
n["melody"] = "baby girl"
d = n
parsed := ConvertInterfaceIntoStringMap(d)
assert.Equal(t, "baby girl", parsed["melody"])
}
func TestConvertInterfaceIntoStringMap_NoType(t *testing.T) {
var d interface{}
n := make(map[string]interface{})
n["melody"] = "baby girl"
d = n
parsed := ConvertInterfaceIntoStringMap(d)
assert.Equal(t, "baby girl", parsed["melody"])
}
func TestConvertInterfaceToStringArray(t *testing.T) {
var d interface{}
n := make(map[string][]string)
n["melody"] = []string{"melody", "is", "my", "baby"}
d = n
parsed := ConvertInterfaceToStringArray(d)
assert.Equal(t, "baby", parsed[3])
}
func TestConvertInterfaceToStringArray_NoType(t *testing.T) {
var d interface{}
m := make([]interface{}, 4)
n := make(map[string]interface{})
m[0] = "melody"
m[1] = "is"
m[2] = "my"
m[3] = "baby"
n["melody"] = m
d = n
parsed := ConvertInterfaceToStringArray(d)
assert.Equal(t, "baby", parsed[3])
}
func TestConvertInterfaceToStringArray_Invalid(t *testing.T) {
var d interface{}
d = "I am a carrot"
parsed := ConvertInterfaceToStringArray(d)
assert.Nil(t, parsed)
}
func TestConvertInterfaceArrayToStringArray(t *testing.T) {
var d interface{}
m := []string{"maddox", "is", "my", "little", "champion"}
d = m
parsed := ConvertInterfaceArrayToStringArray(d)
assert.Equal(t, "little", parsed[3])
}
func TestConvertInterfaceArrayToStringArray_NoType(t *testing.T) {
var d interface{}
m := make([]interface{}, 4)
m[0] = "melody"
m[1] = "is"
m[2] = "my"
m[3] = "baby"
d = m
parsed := ConvertInterfaceArrayToStringArray(d)
assert.Equal(t, "baby", parsed[3])
}
func TestConvertInterfaceArrayToStringArray_Invalid(t *testing.T) {
var d interface{}
d = "weed is good"
parsed := ConvertInterfaceArrayToStringArray(d)
assert.Nil(t, parsed)
}
func TestExtractValueFromInterfaceMap(t *testing.T) {
var d interface{}
m := make(map[string][]string)
m["melody"] = []string{"is", "my", "baby"}
d = m
parsed := ExtractValueFromInterfaceMap("melody", d)
assert.Equal(t, "baby", parsed.([]string)[2])
}
func TestExtractValueFromInterfaceMap_NoType(t *testing.T) {
var d interface{}
m := make(map[string]interface{})
n := make([]interface{}, 3)
n[0] = "maddy"
n[1] = "the"
n[2] = "champion"
m["maddy"] = n
d = m
parsed := ExtractValueFromInterfaceMap("maddy", d)
assert.Equal(t, "champion", parsed.([]interface{})[2])
}
func TestExtractValueFromInterfaceMap_Flat(t *testing.T) {
var d interface{}
m := make(map[string]interface{})
m["maddy"] = "niblet"
d = m
parsed := ExtractValueFromInterfaceMap("maddy", d)
assert.Equal(t, "niblet", parsed.(interface{}))
}
func TestExtractValueFromInterfaceMap_NotFound(t *testing.T) {
var d interface{}
d = "not a map"
parsed := ExtractValueFromInterfaceMap("melody", d)
assert.Nil(t, parsed)
}
func TestFindFirstKeyNode(t *testing.T) {
nodes, _ := FindNodes(getPetstore(), "$")
key, value := FindFirstKeyNode("operationId", nodes, 0)
assert.NotNil(t, key)
assert.NotNil(t, value)
assert.Equal(t, 55, key.Line)
}
func TestFindFirstKeyNode_NotFound(t *testing.T) {
nodes, _ := FindNodes(getPetstore(), "$")
key, value := FindFirstKeyNode("i-do-not-exist-in-the-doc", nodes, 0)
assert.Nil(t, key)
assert.Nil(t, value)
}
func TestFindFirstKeyNode_TooDeep(t *testing.T) {
a, b := FindFirstKeyNode("", nil, 900)
assert.Nil(t, a)
assert.Nil(t, b)
}
func TestFindFirstKeyNode_ValueIsKey(t *testing.T) {
a := &yaml.Node{
Value: "chicken",
}
b := &yaml.Node{
Value: "nuggets",
Content: []*yaml.Node{a},
}
c, d := FindFirstKeyNode("nuggets", []*yaml.Node{b}, 0)
assert.NotNil(t, c)
assert.NotNil(t, d)
assert.Equal(t, c, d)
}
func TestFindFirstKeyNode_Map(t *testing.T) {
nodes, _ := FindNodes(getPetstore(), "$")
key, value := FindFirstKeyNode("pet", nodes, 0)
assert.NotNil(t, key)
assert.NotNil(t, value)
assert.Equal(t, 27, key.Line)
}
func TestFindKeyNodeTop(t *testing.T) {
nodes, _ := FindNodes(getPetstore(), "$")
k, v := FindKeyNodeTop("info", nodes[0].Content)
assert.NotNil(t, k)
assert.NotNil(t, v)
assert.Equal(t, 3, k.Line)
}
func TestFindKeyNodeTop_NotFound(t *testing.T) {
nodes, _ := FindNodes(getPetstore(), "$")
k, v := FindKeyNodeTop("i am a giant potato", nodes[0].Content)
assert.Nil(t, k)
assert.Nil(t, v)
}
func TestFindKeyNode(t *testing.T) {
nodes, _ := FindNodes(getPetstore(), "$")
k, v := FindKeyNode("/pet", nodes[0].Content)
assert.NotNil(t, k)
assert.NotNil(t, v)
assert.Equal(t, 47, k.Line)
}
func TestFindKeyNode_ValueIsKey(t *testing.T) {
a := &yaml.Node{
Value: "chicken",
}
b := &yaml.Node{
Tag: "!!map",
Value: "nuggets",
Content: []*yaml.Node{a},
}
c, d := FindKeyNode("nuggets", []*yaml.Node{b, a})
assert.Equal(t, "nuggets", c.Value)
assert.Equal(t, "chicken", d.Value)
e := &yaml.Node{
Value: "pizza",
}
f := &yaml.Node{
Value: "pie",
}
b.Content = append(b.Content, e, f)
c, d = FindKeyNode("pie", []*yaml.Node{b, a})
assert.Equal(t, "nuggets", c.Value)
assert.Equal(t, "pie", d.Value)
b.Tag = "!!seq"
c, d = FindKeyNode("pie", []*yaml.Node{b, a})
assert.Equal(t, "nuggets", c.Value)
assert.Equal(t, "pie", d.Value)
}
func TestFindExtensionNodes(t *testing.T) {
a := &yaml.Node{
Value: "x-coffee",
}
b := &yaml.Node{
Value: "required",
}
c := &yaml.Node{
Content: []*yaml.Node{a, b},
}
exts := FindExtensionNodes(c.Content)
assert.Len(t, exts, 1)
assert.Equal(t, "required", exts[0].Value.Value)
}
func TestFindKeyNodeFull(t *testing.T) {
a := &yaml.Node{
Value: "fish",
}
b := &yaml.Node{
Value: "paste",
}
c, d, e := FindKeyNodeFull("fish", []*yaml.Node{a, b})
assert.Equal(t, "fish", c.Value)
assert.Equal(t, "fish", d.Value)
assert.Equal(t, "paste", e.Value)
}
func TestFindKeyNodeFull_MapValueIsLastNode(t *testing.T) {
f := &yaml.Node{
Value: "cheese",
}
h := &yaml.Node{
Tag: "!!map",
Value: "deserts", // this is invalid btw, but helps with mechanical understanding
Content: []*yaml.Node{f},
}
c, d, e := FindKeyNodeFull("cheese", []*yaml.Node{h})
assert.Equal(t, "deserts", c.Value)
assert.Equal(t, "cheese", d.Value)
assert.Equal(t, "cheese", e.Value)
}
func TestFindKeyNodeFull_Map(t *testing.T) {
f := &yaml.Node{
Value: "cheese",
}
g := &yaml.Node{
Value: "cake",
}
h := &yaml.Node{
Tag: "!!map",
Value: "deserts", // this is invalid btw, but helps with mechanical understanding
Content: []*yaml.Node{f, g},
}
c, d, e := FindKeyNodeFull("cheese", []*yaml.Node{h})
assert.Equal(t, "deserts", c.Value)
assert.Equal(t, "cheese", d.Value)
assert.Equal(t, "cake", e.Value)
}
func TestFindKeyNodeFull_Array(t *testing.T) {
f := &yaml.Node{
Value: "cheese",
}
g := &yaml.Node{
Value: "cake",
}
h := &yaml.Node{
Tag: "!!seq",
Value: "deserts", // this is invalid btw, but helps with mechanical understanding
Content: []*yaml.Node{f, g},
}
c, d, e := FindKeyNodeFull("cheese", []*yaml.Node{h})
assert.Equal(t, "deserts", c.Value)
assert.Equal(t, "cheese", d.Value)
assert.Equal(t, "cheese", e.Value)
}
func TestFindKeyNodeFull_Nothing(t *testing.T) {
c, d, e := FindKeyNodeFull("cheese", []*yaml.Node{})
assert.Nil(t, c)
assert.Nil(t, d)
assert.Nil(t, e)
}
func TestFindKeyNode_NotFound(t *testing.T) {
nodes, _ := FindNodes(getPetstore(), "$")
k, v := FindKeyNode("I am not anything at all", nodes[0].Content)
assert.Nil(t, k)
assert.Nil(t, v)
}
func TestMakeTagReadable(t *testing.T) {
n := &yaml.Node{
Tag: "!!map",
}
assert.Equal(t, ObjectLabel, MakeTagReadable(n))
n.Tag = "!!seq"
assert.Equal(t, ArrayLabel, MakeTagReadable(n))
n.Tag = "!!str"
assert.Equal(t, StringLabel, MakeTagReadable(n))
n.Tag = "!!int"
assert.Equal(t, IntegerLabel, MakeTagReadable(n))
n.Tag = "!!float"
assert.Equal(t, NumberLabel, MakeTagReadable(n))
n.Tag = "!!bool"
assert.Equal(t, BooleanLabel, MakeTagReadable(n))
n.Tag = "mr potato man is here"
assert.Equal(t, "unknown", MakeTagReadable(n))
}
func TestIsNodeMap(t *testing.T) {
n := &yaml.Node{
Tag: "!!map",
}
assert.True(t, IsNodeMap(n))
n.Tag = "!!pizza"
assert.False(t, IsNodeMap(n))
}
func TestIsNodeMap_Nil(t *testing.T) {
assert.False(t, IsNodeMap(nil))
}
func TestIsNodePolyMorphic(t *testing.T) {
n := &yaml.Node{
Content: []*yaml.Node{
{
Value: "anyOf",
},
},
}
assert.True(t, IsNodePolyMorphic(n))
n.Content[0].Value = "cakes"
assert.False(t, IsNodePolyMorphic(n))
}
func TestIsNodeArray(t *testing.T) {
n := &yaml.Node{
Tag: "!!seq",
}
assert.True(t, IsNodeArray(n))
n.Tag = "!!pizza"
assert.False(t, IsNodeArray(n))
}
func TestIsNodeArray_Nil(t *testing.T) {
assert.False(t, IsNodeArray(nil))
}
func TestIsNodeStringValue(t *testing.T) {
n := &yaml.Node{
Tag: "!!str",
}
assert.True(t, IsNodeStringValue(n))
n.Tag = "!!pizza"
assert.False(t, IsNodeStringValue(n))
}
func TestIsNodeStringValue_Nil(t *testing.T) {
assert.False(t, IsNodeStringValue(nil))
}
func TestIsNodeIntValue(t *testing.T) {
n := &yaml.Node{
Tag: "!!int",
}
assert.True(t, IsNodeIntValue(n))
n.Tag = "!!pizza"
assert.False(t, IsNodeIntValue(n))
}
func TestIsNodeIntValue_Nil(t *testing.T) {
assert.False(t, IsNodeIntValue(nil))
}
func TestIsNodeFloatValue(t *testing.T) {
n := &yaml.Node{
Tag: "!!float",
}
assert.True(t, IsNodeFloatValue(n))
n.Tag = "!!pizza"
assert.False(t, IsNodeFloatValue(n))
}
func TestIsNodeFloatValue_Nil(t *testing.T) {
assert.False(t, IsNodeFloatValue(nil))
}
func TestIsNodeBoolValue(t *testing.T) {
n := &yaml.Node{
Tag: "!!bool",
}
assert.True(t, IsNodeBoolValue(n))
n.Tag = "!!pizza"
assert.False(t, IsNodeBoolValue(n))
}
func TestIsNodeBoolValue_Nil(t *testing.T) {
assert.False(t, IsNodeBoolValue(nil))
}
func TestFixContext(t *testing.T) {
assert.Equal(t, "$.nuggets[12].name", FixContext("(root).nuggets.12.name"))
}
func TestFixContext_HttpCode(t *testing.T) {
assert.Equal(t, "$.nuggets.404.name", FixContext("(root).nuggets.404.name"))
}
func TestIsJSON(t *testing.T) {
assert.True(t, IsJSON("{'hello':'there'}"))
assert.False(t, IsJSON("potato shoes"))
assert.False(t, IsJSON(""))
}
func TestIsYAML(t *testing.T) {
assert.True(t, IsYAML("hello:\n there:\n my-name: is quobix"))
assert.True(t, IsYAML("potato shoes"))
assert.False(t, IsYAML("{'hello':'there'}"))
assert.False(t, IsYAML(""))
assert.False(t, IsYAML("8908: hello: yeah: \n12309812: :123"))
}
func TestConvertYAMLtoJSON(t *testing.T) {
str, err := ConvertYAMLtoJSON([]byte("hello: there"))
assert.NoError(t, err)
assert.NotNil(t, str)
assert.Equal(t, "{\"hello\":\"there\"}", string(str))
str, err = ConvertYAMLtoJSON([]byte("gonna: break: you:\nyeah:yeah:yeah"))
assert.Error(t, err)
assert.Nil(t, str)
}
func TestIsHttpVerb(t *testing.T) {
assert.True(t, IsHttpVerb("get"))
assert.True(t, IsHttpVerb("post"))
assert.False(t, IsHttpVerb("nuggets"))
}
func TestConvertComponentIdIntoFriendlyPathSearch(t *testing.T) {
segment, path := ConvertComponentIdIntoFriendlyPathSearch("#/chicken/chips/pizza/cake")
assert.Equal(t, "$.chicken.chips.pizza['cake']", path)
assert.Equal(t, "cake", segment)
}
func TestConvertComponentIdIntoFriendlyPathSearch_WithRootSymbol(t *testing.T) {
segment, path := ConvertComponentIdIntoFriendlyPathSearch("/chicken/chips/pizza/cake")
assert.Equal(t, "$.chicken.chips.pizza['cake']", path)
assert.Equal(t, "cake", segment)
}
func TestConvertComponentIdIntoPath(t *testing.T) {
segment, path := ConvertComponentIdIntoPath("#/chicken/chips/pizza/cake")
assert.Equal(t, "$.chicken.chips.pizza.cake", path)
assert.Equal(t, "cake", segment)
}
func TestDetectCase(t *testing.T) {
assert.Equal(t, PascalCase, DetectCase("PizzaPie"))
assert.Equal(t, CamelCase, DetectCase("anyoneForTennis"))
assert.Equal(t, ScreamingSnakeCase, DetectCase("I_LOVE_BEER"))
assert.Equal(t, ScreamingKebabCase, DetectCase("I-LOVE-BURGERS"))
assert.Equal(t, SnakeCase, DetectCase("snakes_on_a_plane"))
assert.Equal(t, KebabCase, DetectCase("chicken-be-be-beef-or-pork"))
assert.Equal(t, RegularCase, DetectCase("kebab-TimeIn_london-TOWN"))
}
func TestIsNodeRefValue(t *testing.T) {
f := &yaml.Node{
Value: "$ref",
}
g := &yaml.Node{
Value: "'#/somewhere/out-there'",
}
h := &yaml.Node{
Tag: "!!map",
Content: []*yaml.Node{f, g},
}
ref, node, val := IsNodeRefValue(h)
assert.True(t, ref)
assert.Equal(t, "$ref", node.Value)
assert.Equal(t, "'#/somewhere/out-there'", val)
}
func TestIsNodeRefValue_False(t *testing.T) {
f := &yaml.Node{
Value: "woof",
}
g := &yaml.Node{
Value: "dog",
}
h := &yaml.Node{
Tag: "!!map",
Content: []*yaml.Node{f, g},
}
ref, node, val := IsNodeRefValue(h)
assert.False(t, ref)
assert.Nil(t, node)
assert.Empty(t, val)
}
func TestCheckEnumForDuplicates_Success(t *testing.T) {
yml := "- yes\n- no\n- crisps"
var rootNode yaml.Node
yaml.Unmarshal([]byte(yml), &rootNode)
assert.Len(t, CheckEnumForDuplicates(rootNode.Content[0].Content), 0)
}
func TestCheckEnumForDuplicates_Fail(t *testing.T) {
yml := "- yes\n- no\n- crisps\n- no"
var rootNode yaml.Node
yaml.Unmarshal([]byte(yml), &rootNode)
assert.Len(t, CheckEnumForDuplicates(rootNode.Content[0].Content), 1)
}
func TestCheckEnumForDuplicates_FailMultiple(t *testing.T) {
yml := "- yes\n- no\n- crisps\n- no\n- rice\n- yes\n- no"
var rootNode yaml.Node
yaml.Unmarshal([]byte(yml), &rootNode)
assert.Len(t, CheckEnumForDuplicates(rootNode.Content[0].Content), 3)
}
Reference in New Issue View Git Blame Copy Permalink