feat: adding step 'pods converge to selector'

.github/workflows/ci.yml

@@ -21,7 +21,9 @@ jobs:
     - name: Run 'all' make target
       run: make all
     - name: Codecov
-      uses: codecov/codecov-action@v3
+      uses: codecov/codecov-action@v4
+      env:
+        CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
       with:
         file: ./coverage.txt # optional
         flags: unittests # optional

codecov.yml

@@ -0,0 +1,8 @@
+coverage:
+  range: "70...90"
+  round: down
+  precision: 2
+
+ignore:
+  - "examples"
+  - "generate"

docs/syntax.md

@@ -34,6 +34,7 @@ Below you will find the step syntax next to the name of the method it utilizes.
 - `<GK> some pods in namespace <non-whitespace-characters> with selector <non-whitespace-characters> don't have "<any-characters-except-(")>" in logs since <any-characters-except-(")> time` kdt.KubeClientSet.SomePodsInNamespaceWithSelectorDontHaveStringInLogsSinceTime
 - `<GK> [the] pods in namespace <non-whitespace-characters> with selector <non-whitespace-characters> have no errors in logs since <any-characters-except-(")> time` kdt.KubeClientSet.PodsInNamespaceWithSelectorHaveNoErrorsInLogsSinceTime
 - `<GK> [the] pods in namespace <non-whitespace-characters> with selector <non-whitespace-characters> have some errors in logs since <any-characters-except-(")> time` kdt.KubeClientSet.PodsInNamespaceWithSelectorHaveSomeErrorsInLogsSinceTime
+- `<GK> [all] [the] (pod|pods) in [the] namespace <non-whitespace-characters> with [the] label selector <non-whitespace-characters> [should] converge to [the] field selector <non-whitespace-characters>` kdt.KubeClientSet.PodsInNamespaceWithLabelSelectorConvergeToFieldSelector
 - `<GK> [the] pods in namespace <non-whitespace-characters> with selector <non-whitespace-characters> should have labels <non-whitespace-characters>` kdt.KubeClientSet.PodsInNamespaceWithSelectorShouldHaveLabels
 - `<GK> [the] pod <non-whitespace-characters> in namespace <non-whitespace-characters> should have labels <non-whitespace-characters>` kdt.KubeClientSet.PodInNamespaceShouldHaveLabels
 

generate/syntax/main.go

@@ -21,6 +21,7 @@ import (
 	"strconv"
 	"strings"
 
+	"github.com/keikoproj/kubedog/generate/syntax/replace"
 	log "github.com/sirupsen/logrus"
 )
 
@@ -48,18 +49,37 @@ const (
 	destinationFileBeginning = "# Syntax" + newLine + "Below you will find the step syntax next to the name of the method it utilizes. Here GK stands for [Gherkin](https://cucumber.io/docs/gherkin/reference/#keywords) Keyword and words in brackets ([]) are optional:" + newLine
 )
 
-var replacers = []struct {
-	replacee string
-	replacer string
-}{
-	{`(?:`, `[`},
-	{` )?`, `] `},
-	{`)?`, `]`},
-	{`(\d+)`, `<digits>`},
-	{`(\S+)`, `<non-whitespace-characters>`},
-	{`([^"]*)`, `<any-characters-except-(")>`},
-	{`\(`, `(`},
-	{`\)`, `)`},
+var replacements = replace.Replacements{
+	{Replacee: `(\d+)`, Replacer: `<digits>`},
+	{Replacee: `(\S+)`, Replacer: `<non-whitespace-characters>`},
+	{Replacee: `([^"]*)`, Replacer: `<any-characters-except-(")>`},
+}
+
+var bracketsReplacements = replace.BracketsReplacements{
+	{
+		Opening: replace.Replacement{
+			Replacee: `(?:`, Replacer: `[`},
+		Closing: replace.Replacement{
+			Replacee: ` )?`, Replacer: `] `},
+	},
+	{
+		Opening: replace.Replacement{
+			Replacee: `(?:`, Replacer: `[`},
+		Closing: replace.Replacement{
+			Replacee: `)?`, Replacer: `]`},
+	},
+	{
+		Opening: replace.Replacement{
+			Replacee: `(?:`, Replacer: `(`},
+		Closing: replace.Replacement{
+			Replacee: `)`, Replacer: `)`},
+	},
+	{
+		Opening: replace.Replacement{
+			Replacee: `\(`, Replacer: `(`},
+		Closing: replace.Replacement{
+			Replacee: `\)`, Replacer: `)`},
+	},
 }
 
 func main() {
@@ -143,9 +163,8 @@ func processStep(rawStep string) string {
 	processedStep := rawStepSplit[1]
 	processedStep = strings.TrimPrefix(processedStep, stepPrefix)
 	processedStep = strings.TrimSuffix(processedStep, stepSuffix)
-	for _, r := range replacers {
-		processedStep = strings.ReplaceAll(processedStep, r.replacee, r.replacer)
-	}
+	processedStep = replacements.Replace(processedStep)
+	processedStep = bracketsReplacements.Replace(processedStep)
 	method := rawStepSplit[2]
 	method = strings.TrimPrefix(method, methodPrefix)
 	method = strings.TrimSuffix(method, methodSuffix)

generate/syntax/replace/replace.go

@@ -0,0 +1,89 @@
+/*
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package replace
+
+import (
+	"bytes"
+	"log"
+	"regexp"
+	"strings"
+)
+
+const regExp_CharsWithinBrackets = "([^(]*)"
+
+type Replacement struct {
+	Replacee string
+	Replacer string
+}
+
+func (r Replacement) Replace(src string) string {
+	return strings.ReplaceAll(src, r.Replacee, r.Replacer)
+}
+
+type Replacements []Replacement
+
+func (rs Replacements) Replace(src string) string {
+	new := src
+	for _, r := range rs {
+		new = r.Replace(new)
+	}
+	return new
+}
+
+type BracketsReplacement struct {
+	Opening Replacement
+	Closing Replacement
+}
+
+func (br BracketsReplacement) Replace(src string) string {
+	re, err := regexp.Compile(br.getRegExp())
+	if err != nil {
+		log.Fatal(err)
+	}
+	new := re.ReplaceAllFunc([]byte(src), br.replaceSingle)
+	return string(new)
+}
+
+func (br BracketsReplacement) replaceSingle(src []byte) []byte {
+	s := string(src)
+	s = br.Opening.Replace(s)
+	s = br.Closing.Replace(s)
+	return []byte(s)
+}
+
+func (br BracketsReplacement) getRegExp() string {
+	return escapeEveryCharacter(br.Opening.Replacee) +
+		regExp_CharsWithinBrackets +
+		escapeEveryCharacter(br.Closing.Replacee)
+}
+
+func escapeEveryCharacter(s string) string {
+	var buffer bytes.Buffer
+	for _, c := range s {
+		buffer.WriteString(`\`)
+		buffer.WriteRune(c)
+	}
+	return buffer.String()
+}
+
+type BracketsReplacements []BracketsReplacement
+
+func (brs BracketsReplacements) Replace(src string) string {
+	new := src
+	for _, br := range brs {
+		new = br.Replace(new)
+	}
+	return new
+}