2024-03-20 16:36:20 +00:00
package postman
import (
"reflect"
"sort"
"strings"
"testing"
)
func TestNewSubstitution ( t * testing . T ) {
sub := NewSubstitution ( )
if sub . variables == nil {
t . Error ( "NewSubstitution should initialize variables map" )
}
}
func TestSubstitution_Add ( t * testing . T ) {
sub := NewSubstitution ( )
metadata := Metadata {
CollectionInfo : Info { PostmanID : "col1" } ,
}
sub . add ( metadata , "key1" , "value1" )
sub . add ( metadata , "key1" , "value2" )
sub . add ( metadata , "key2" , "value3" )
expected := map [ string ] [ ] VariableInfo {
"key1" : {
{ value : "value1" , Metadata : metadata } ,
{ value : "value2" , Metadata : metadata } ,
} ,
"key2" : {
{ value : "value3" , Metadata : metadata } ,
} ,
}
if ! reflect . DeepEqual ( sub . variables , expected ) {
t . Errorf ( "Expected variables: %+v, got: %+v" , expected , sub . variables )
}
}
func TestSource_KeywordCombinations ( t * testing . T ) {
s := & Source {
DetectorKeywords : map [ string ] struct { } {
"keyword1" : { } ,
"keyword2" : { } ,
} ,
keywords : make ( map [ string ] struct { } ) ,
}
2024-05-16 19:03:03 +00:00
s . attemptToAddKeyword ( "keyword1" )
s . attemptToAddKeyword ( "keyword2" )
s . attemptToAddKeyword ( "keyword3" )
2024-03-20 16:36:20 +00:00
// remove that \n from the end of the string
got := strings . Split ( strings . TrimSuffix ( s . keywordCombinations ( "test" ) , "\n" ) , "\n" )
expected := [ ] string { "keyword1:test" , "keyword2:test" }
sort . Strings ( got )
sort . Strings ( expected )
if ! reflect . DeepEqual ( got , expected ) {
t . Errorf ( "Expected keyword combinations: %q, got: %q" , expected , got )
}
}
func TestSource_BuildSubstituteSet ( t * testing . T ) {
s := & Source {
sub : NewSubstitution ( ) ,
}
s . sub . add ( Metadata { Type : GLOBAL_TYPE } , "var1" , "value1" )
s . sub . add ( Metadata { Type : GLOBAL_TYPE } , "var2" , "value2" )
2024-05-02 18:03:03 +00:00
s . sub . add ( Metadata { Type : GLOBAL_TYPE } , "" , "value2" )
s . sub . add ( Metadata { Type : GLOBAL_TYPE } , "continuation_token" , "'{{continuation_token}}'" ) // this caused an infinite loop in the original implementation
s . sub . add ( Metadata { Type : GLOBAL_TYPE } , "continuation_token2" , "'{{{continuation_token2}}}'" ) // this caused an infinite loop in the original implementation
2024-03-20 16:36:20 +00:00
metadata := Metadata {
Type : GLOBAL_TYPE ,
}
testCases := [ ] struct {
data string
expected [ ] string
} {
{ "{{var1}}" , [ ] string { "value1" } } ,
{ "{{var2}}" , [ ] string { "value2" } } ,
{ "{{var1}}:{{var2}}" , [ ] string { "value1:value2" } } ,
{ "no variables" , [ ] string { "no variables" } } ,
2024-05-02 18:03:03 +00:00
{ "{{var1}}:{{continuation_token}}" , [ ] string { "value1:'continuation_token'" } } ,
{ "{{var1}}:{{continuation_token2}}" , [ ] string { "value1:'{continuation_token2}'" } } ,
2024-03-20 16:36:20 +00:00
}
for _ , tc := range testCases {
result := s . buildSubstitueSet ( metadata , tc . data )
if ! reflect . DeepEqual ( result , tc . expected ) {
t . Errorf ( "Expected substitution set: %v, got: %v" , tc . expected , result )
}
}
}
func TestRemoveDuplicateStr ( t * testing . T ) {
testCases := [ ] struct {
input [ ] string
expected [ ] string
} {
{ [ ] string { "a" , "b" , "c" , "a" , "b" } , [ ] string { "a" , "b" , "c" } } ,
{ [ ] string { "a" , "a" , "a" } , [ ] string { "a" } } ,
{ [ ] string { } , [ ] string { } } ,
}
for _ , tc := range testCases {
result := removeDuplicateStr ( tc . input )
if ! reflect . DeepEqual ( result , tc . expected ) {
t . Errorf ( "Expected result: %v, got: %v" , tc . expected , result )
}
}
}
func TestSource_FormatAndInjectKeywords ( t * testing . T ) {
s := & Source {
DetectorKeywords : map [ string ] struct { } {
"keyword1" : { } ,
"keyword2" : { } ,
} ,
keywords : make ( map [ string ] struct { } ) ,
}
2024-05-16 19:03:03 +00:00
s . attemptToAddKeyword ( "keyword1" )
s . attemptToAddKeyword ( "keyword2" )
s . attemptToAddKeyword ( "keyword3" )
2024-03-20 16:36:20 +00:00
testCases := [ ] struct {
input [ ] string
expected string
} {
{
[ ] string { "data1" , "data2" } ,
"keyword1:data1\nkeyword2:data1\nkeyword1:data2\nkeyword2:data2\n" ,
} ,
{
[ ] string { "data1" } ,
"keyword1:data1\nkeyword2:data1\n" ,
} ,
{
[ ] string { } ,
"" ,
} ,
}
for _ , tc := range testCases {
result := s . formatAndInjectKeywords ( tc . input )
got := strings . Split ( result , "\n" )
expected := strings . Split ( tc . expected , "\n" )
sort . Strings ( got )
sort . Strings ( expected )
if ! reflect . DeepEqual ( got , expected ) {
t . Errorf ( "Expected result: %q, got: %q" , tc . expected , result )
}
}
}