ADD TEST CASES TO THE RESULT CODE OF EXTRACT VARIABLES FROM TEMPLATE #1

[patrick-hermann-sva]

for those two functions we need test cases (each)!

example! try it out to understand!

cat <<EOF > ankit.go
package main

import "fmt"

func Sum(x int, y int) int {
        return x + y
}

func main() {
        Sum(5, 5)
        fmt.Println(Sum(5, 5))
}
EOF

cat <<EOF > ankit_test.go
package main

import "testing"

func TestSum(t *testing.T) {

	type test struct {
		number1 int
		number2 int
		want    int
	}

	tests := []test{
		{number1: 5, number2: 2, want: 7},
		{number1: 6, number2: 9, want: 15},
		{number1: 7, number2: 112, want: 119},
	}

	for _, tc := range tests {

		total := Sum(tc.number1, tc.number2)

		if total != tc.want {
			t.Errorf("Sum was incorrect, got: %d, want: %d.", total, tc.want)
		}

	}

}

EOF

go mod init ankit
go mod tidy

go run ankit.go
go test -v

we want to test those two functions w/ proper test cases

e.g. input: []string{"Kind", "Name", "Name"}
expected output: []string{"Kind", "Name"}

func removeDuplicateStr(results []string) []string {
    allKeys := make(map[string]bool)
    list := []string{}
    for _, item := range results {
        if _, value := allKeys[item]; !value {
            allKeys[item] = true
            list = append(list, item)
        }
    }
    return list
}

func GetAllRegexMatches(scanText, regexPattern string) []string {

	re := regexp.MustCompile(regexPattern)

	return re.FindAllString(scanText, -1)
}

[patrick-hermann-sva]

another example!

mkdir ankit3 && cd ankit3
cat <<EOF > ankit3.go
package main

import "fmt"

func removeDuplicateStr(results []string) []string {
	allKeys := make(map[string]bool)
	list := []string{}
	for _, item := range results {
		if _, value := allKeys[item]; !value {
			allKeys[item] = true
			list = append(list, item)
		}
	}
	return list
}

func main() {

	testData := []string{"Kind", "Name", "Name"}
	testOutput := removeDuplicateStr(testData)
	fmt.Println(testOutput)

}
EOF

cat <<EOF > ankit3_test.go
package main

import (
	"fmt"
	"reflect"
	"testing"
)

func TestRemoveDuplicateStr(t *testing.T) {

	type test struct {
		testInput []string
		want      []string
	}

	tests := []test{
		{testInput: []string{"Kind", "Name", "Name"}, want: []string{"Kind", "Name"}},
	}

	for _, tc := range tests {

		removed := removeDuplicateStr(tc.testInput)

		fmt.Println(removed)
		fmt.Println(tc.want)

		if !reflect.DeepEqual(removed, tc.want) {
			t.Errorf("Slices are not equal, BUT we expected them to be...")
		}

	}

}

EOF

go mod init ankit
go mod tidy

go run ankit.go
go test -v

[ankitsharma12-ops]

second tests case

mkdir ankit4
cat << EOF > ankit4.go
package main

import (
	"fmt"
	"regexp"
)

func main() {
	//
		scanText := "{{ .Kind }}"
		testPattern := `\{\{(.*?)\}\}`
		testOutput := GetAllRegexMatches(scanText, testPattern)
		fmt.Println(testOutput)
		
	//
}
func GetAllRegexMatches(scanText, regexPattern string) []string {

	re := regexp.MustCompile(regexPattern)
	fmt.Println(re)
	return re.FindAllString(scanText, -1)
	
}
EOF

cat <<EOF > ankit3_test.go
package main

import (
	"testing"
	"reflect"
	"fmt"
)

func TestGetRegexMatch(t *testing.T) {
	type test struct {
		scanText string
		testPattern string
		want      []string
	}

	tests := []test{
		{scanText: "whatever {{ .Kind1 }}", testPattern: `\{\{(.*?)\}\}`, want: []string{"{{ .Kind1 }}"}},
		{scanText: "{{ .Name }}", testPattern: `\{\{(.*?)\}\}`, want: []string{"{{ .Name }}"}},
	}
	for _, tc := range tests {

		scanresult := GetAllRegexMatches(tc.scanText, tc.testPattern)
		fmt.Println(scanresult)
		fmt.Println(reflect.DeepEqual(scanresult, tc.want))
		if !reflect.DeepEqual(scanresult, tc.want) {
			t.Errorf("error")
	
		}	
	}
}
EOF

and test it, it works like this:

shq1kor@BMH2-C-00134:~/development/projects/go/src/ankit1$ go test -v
=== RUN   TestGetRegexMatch
\{\{(.*?)\}\}
[{{ .Kind1 }}]
true
\{\{(.*?)\}\}
[{{ .Name }}]
true
--- PASS: TestGetRegexMatch (0.00s)
PASS
ok      ankit   0.002s

[patrick-hermann-sva]

@ankitsharma12-ops TASK1

Update the following code that we have at the end trimedResults w/ Name and Kind1 (WITHOUT . + WITHOUT {{ and WITHOUT }})

// You can edit this code!
// Click here and start typing.
package main

import (
	"fmt"
	"reflect"
	"regexp"
	"strings"
	"testing"
)

func TestGetRegexMatch(t *testing.T) {
	type test struct {
		scanText    string
		testPattern string
		want        []string
	}

	tests := []test{
		{scanText: "whatever {{ .Kind1 }}", testPattern: `\{\{(.*?)\}\}`, want: []string{"{{ .Kind1 }}"}},
		{scanText: "{{ .Name }}", testPattern: `\{\{(.*?)\}\}`, want: []string{"{{ .Name }}"}},
	}

	for _, tc := range tests {

		scanresult := GetAllRegexMatches(tc.scanText, tc.testPattern)
		fmt.Println(scanresult)

		// RESULT HERE IS {{ .Kind1 }} BUUUUT WE NEED JUST Kind1 (WITHOUT . + WITHOUT {{ and WITHOUT }})

		var trimedResults []string

		for _, result := range scanresult {
			fmt.Println("THIS IS INSIDE THE REULTS")
			fmt.Println(result)

			fmt.Println("THIS IS WITHOUT THE DOT")
			woDot := strings.Replace(result, ".", "", -1)
			fmt.Println(woDot)

			// REPLACE {{
			// REPLACE }}
			// TRIM SPACE

			trimedResults = append(trimedResults, woDot)
		}

		fmt.Println("THIS IS ARE THE RESULTS WE CARE FOR..")
		fmt.Println(trimedResults)

		fmt.Println(reflect.DeepEqual(scanresult, tc.want))
		if !reflect.DeepEqual(scanresult, tc.want) {
			t.Errorf("error")

		}
	}

}

func GetAllRegexMatches(scanText, regexPattern string) []string {

	re := regexp.MustCompile(regexPattern)
	fmt.Println(re)
	return re.FindAllString(scanText, -1)

}

[patrick-hermann-sva]

@ankitsharma12-ops

package main

import "fmt"

func main() {

	// new maps
	ankit := make(map[string]string)
	boss := make(map[string]string)

	ankit["food"] = "lamb"
	ankit["team"] = "manu"
	ankit["tool"] = "k9s"

	boss["food"] = "chicken"
	boss["team"] = "stuttgart"

	// FIND A WAY TO COMPARE BOTH MAPS -> BOTH OF THEM SHOULD CONTAIN THE SAME KEYS ( WE DO NOT CARE ABOUT THE VALUES - JUST THE KEYS)

	// OR YOU COMARE ONE MAP INSIDE A LOOP WITH A STRING SLICE - ALSO OK!
	keys := []string{"food", "team", "tool"}
	for _, key := range keys {
		fmt.Println(key)
		fmt.Println(boss[key])
		if boss[key] == "" {
			fmt.Println("Looks bad - no key for boss")
		}
	}

}