// Copyright 2023 Harness, Inc.
//
// 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 parser
import (
"reflect"
"strings"
"testing"
)
//nolint:gocognit // it's a unit test!!!
func TestDiffCut(t *testing.T) {
const input = `diff --git a/test.txt b/test.txt
--- a/test.txt
+++ b/test.txt
@@ -1,15 +1,11 @@
+0
1
2
3
4
5
-6
-7
-8
+6,7,8
9
10
11
12
-13
-14
-15
`
tests := []struct {
name string
params DiffCutParams
expCutHeader string
expCut []string
expError error
}{
{
name: "at-'+6,7,8':new",
params: DiffCutParams{
LineStart: 7, LineStartNew: true,
LineEnd: 7, LineEndNew: true,
BeforeLines: 0, AfterLines: 0,
LineLimit: 1000,
},
expCutHeader: "@@ -6,3 +7 @@",
expCut: []string{"-6", "-7", "-8", "+6,7,8"},
expError: nil,
},
{
name: "at-'+6,7,8':new-with-lines-around",
params: DiffCutParams{
LineStart: 7, LineStartNew: true,
LineEnd: 7, LineEndNew: true,
BeforeLines: 1, AfterLines: 2,
LineLimit: 1000,
},
expCutHeader: "@@ -5,6 +6,4 @@",
expCut: []string{" 5", "-6", "-7", "-8", "+6,7,8", " 9", " 10"},
expError: nil,
},
{
name: "at-'+0':new-with-lines-around",
params: DiffCutParams{
LineStart: 1, LineStartNew: true,
LineEnd: 1, LineEndNew: true,
BeforeLines: 3, AfterLines: 3,
LineLimit: 1000,
},
expCutHeader: "@@ -1,3 +1,4 @@",
expCut: []string{"+0", " 1", " 2", " 3"},
expError: nil,
},
{
name: "at-'-13':one-with-lines-around",
params: DiffCutParams{
LineStart: 13, LineStartNew: false,
LineEnd: 13, LineEndNew: false,
BeforeLines: 1, AfterLines: 1,
LineLimit: 1000,
},
expCutHeader: "@@ -12,3 +11 @@",
expCut: []string{" 12", "-13", "-14"},
expError: nil,
},
{
name: "at-'-13':mixed",
params: DiffCutParams{
LineStart: 7, LineStartNew: false,
LineEnd: 7, LineEndNew: true,
BeforeLines: 0, AfterLines: 0,
LineLimit: 0,
},
expCutHeader: "@@ -7,2 +7 @@",
expCut: []string{"-7", "-8", "+6,7,8"},
expError: nil,
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
hunkHeader, linesHunk, err := DiffCut(
strings.NewReader(input),
test.params,
)
//nolint:errorlint // this error will not be wrapped
if want, got := test.expError, err; want != got {
t.Errorf("error mismatch: want=%v got=%v", want, got)
return
}
if err != nil {
return
}
if test.params.LineStartNew && test.params.LineStart != hunkHeader.NewLine {
t.Errorf("hunk line start mismatch: want=%d got=%d", test.params.LineStart, hunkHeader.NewLine)
}
if !test.params.LineStartNew && test.params.LineStart != hunkHeader.OldLine {
t.Errorf("hunk line start mismatch: want=%d got=%d", test.params.LineStart, hunkHeader.OldLine)
}
if want, got := test.expCutHeader, linesHunk.String(); want != got {
t.Errorf("header mismatch: want=%s got=%s", want, got)
}
if want, got := test.expCut, linesHunk.Lines; !reflect.DeepEqual(want, got) {
t.Errorf("lines mismatch: want=%s got=%s", want, got)
}
})
}
}
func TestDiffCutNoEOLInOld(t *testing.T) {
const input = `diff --git a/test.txt b/test.txt
index 541cb64f..047d7ee2 100644
--- a/test.txt
+++ b/test.txt
@@ -1 +1,4 @@
-test
\ No newline at end of file
+123
+456
+789
`
hh, h, err := DiffCut(
strings.NewReader(input),
DiffCutParams{
LineStart: 3,
LineStartNew: true,
LineEnd: 3,
LineEndNew: true,
BeforeLines: 1,
AfterLines: 1,
LineLimit: 100,
},
)
if err != nil {
t.Errorf("got error: %v", err)
return
}
expectedHH := HunkHeader{OldLine: 2, OldSpan: 0, NewLine: 3, NewSpan: 1}
if expectedHH != hh {
t.Errorf("expected hunk header: %+v, but got: %+v", expectedHH, hh)
}
expectedHunkLines := Hunk{
HunkHeader: HunkHeader{OldLine: 2, OldSpan: 0, NewLine: 2, NewSpan: 2},
Lines: []string{"+456", "+789"},
}
if !reflect.DeepEqual(expectedHunkLines, h) {
t.Errorf("expected hunk header: %+v, but got: %+v", expectedHunkLines, h)
}
}
func TestDiffCutNoEOLInNew(t *testing.T) {
const input = `diff --git a/test.txt b/test.txt
index af7864ba..541cb64f 100644
--- a/test.txt
+++ b/test.txt
@@ -1,3 +1 @@
-123
-456
-789
+test
\ No newline at end of file
`
hh, h, err := DiffCut(
strings.NewReader(input),
DiffCutParams{
LineStart: 1,
LineStartNew: true,
LineEnd: 1,
LineEndNew: true,
BeforeLines: 0,
AfterLines: 0,
LineLimit: 100,
},
)
if err != nil {
t.Errorf("got error: %v", err)
return
}
expectedHH := HunkHeader{OldLine: 1, OldSpan: 3, NewLine: 1, NewSpan: 1}
if expectedHH != hh {
t.Errorf("expected hunk header: %+v, but got: %+v", expectedHH, hh)
}
expectedHunkLines := Hunk{
HunkHeader: HunkHeader{OldLine: 1, OldSpan: 3, NewLine: 1, NewSpan: 1},
Lines: []string{"-123", "-456", "-789", "+test"},
}
if !reflect.DeepEqual(expectedHunkLines, h) {
t.Errorf("expected hunk header: %+v, but got: %+v", expectedHunkLines, h)
}
}
func TestBlobCut(t *testing.T) {
const input = `1
2
3
4
5
6`
tests := []struct {
name string
params DiffCutParams
expCutHeader CutHeader
expCut Cut
expError error
}{
{
name: "first 3 lines",
params: DiffCutParams{LineStart: 1, LineEnd: 3, LineLimit: 40},
expCutHeader: CutHeader{Line: 1, Span: 3},
expCut: Cut{CutHeader: CutHeader{Line: 1, Span: 3}, Lines: []string{"1", "2", "3"}},
},
{
name: "last 2 lines",
params: DiffCutParams{LineStart: 5, LineEnd: 6, LineLimit: 40},
expCutHeader: CutHeader{Line: 5, Span: 2},
expCut: Cut{CutHeader: CutHeader{Line: 5, Span: 2}, Lines: []string{"5", "6"}},
},
{
name: "first 3 lines with 1 more",
params: DiffCutParams{LineStart: 1, LineEnd: 3, BeforeLines: 1, AfterLines: 1, LineLimit: 40},
expCutHeader: CutHeader{Line: 1, Span: 3},
expCut: Cut{CutHeader: CutHeader{Line: 1, Span: 4}, Lines: []string{"1", "2", "3", "4"}},
},
{
name: "last 2 lines with 2 more",
params: DiffCutParams{LineStart: 5, LineEnd: 6, BeforeLines: 2, AfterLines: 2, LineLimit: 40},
expCutHeader: CutHeader{Line: 5, Span: 2},
expCut: Cut{CutHeader: CutHeader{Line: 3, Span: 4}, Lines: []string{"3", "4", "5", "6"}},
},
{
name: "mid range",
params: DiffCutParams{LineStart: 2, LineEnd: 4, BeforeLines: 100, AfterLines: 100, LineLimit: 40},
expCutHeader: CutHeader{Line: 2, Span: 3},
expCut: Cut{CutHeader: CutHeader{Line: 1, Span: 6}, Lines: []string{"1", "2", "3", "4", "5", "6"}},
},
{
name: "out of range 1",
params: DiffCutParams{LineStart: 15, LineEnd: 17, LineLimit: 40},
expError: ErrHunkNotFound,
},
{
name: "out of range 2",
params: DiffCutParams{LineStart: 5, LineEnd: 7, BeforeLines: 1, AfterLines: 1, LineLimit: 40},
expError: ErrHunkNotFound,
},
{
name: "limited",
params: DiffCutParams{LineStart: 3, LineEnd: 4, BeforeLines: 1, AfterLines: 1, LineLimit: 3},
expCutHeader: CutHeader{Line: 3, Span: 2},
expCut: Cut{CutHeader: CutHeader{Line: 2, Span: 3}, Lines: []string{"2", "3", "4"}},
},
{
name: "unlimited",
params: DiffCutParams{LineStart: 1, LineEnd: 6, BeforeLines: 1, AfterLines: 1, LineLimit: 0},
expCutHeader: CutHeader{Line: 1, Span: 6},
expCut: Cut{CutHeader: CutHeader{Line: 1, Span: 6}, Lines: []string{"1", "2", "3", "4", "5", "6"}},
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
ch, c, err := BlobCut(strings.NewReader(input), test.params)
if err != test.expError { //nolint:errorlint // it's a unit test and no errors are wrapped
t.Errorf("test failed with error: %s", err.Error())
return
}
if want, got := test.expCutHeader, ch; want != got {
t.Errorf("cut header: want=%+v got: %+v", want, got)
}
if want, got := test.expCut, c; !reflect.DeepEqual(want, got) {
t.Errorf("cut: want=%+v got: %+v", want, got)
}
})
}
}
func TestStrCircBuf(t *testing.T) {
tests := []struct {
name string
cap int
feed []string
exp []string
}{
{name: "empty", cap: 10, feed: nil, exp: []string{}},
{name: "zero-cap", cap: 0, feed: []string{"A", "B"}, exp: []string{}},
{name: "one", cap: 5, feed: []string{"A"}, exp: []string{"A"}},
{name: "two", cap: 3, feed: []string{"A", "B"}, exp: []string{"A", "B"}},
{name: "cap", cap: 3, feed: []string{"A", "B", "C"}, exp: []string{"A", "B", "C"}},
{name: "cap+1", cap: 3, feed: []string{"A", "B", "C", "D"}, exp: []string{"B", "C", "D"}},
{name: "cap+2", cap: 3, feed: []string{"A", "B", "C", "D", "E"}, exp: []string{"C", "D", "E"}},
{name: "cap*2+1", cap: 2, feed: []string{"A", "B", "C", "D", "E"}, exp: []string{"D", "E"}},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
b := newStrCircBuf(test.cap)
for _, s := range test.feed {
b.push(s)
}
if want, got := test.exp, b.lines(); !reflect.DeepEqual(want, got) {
t.Errorf("want=%v, got=%v", want, got)
}
})
}
}