range_test.go

package vers

import "testing"

func TestRangeContains(t *testing.T) {
	tests := []struct {
		name    string
		r       *Range
		version string
		want    bool
	}{
		{
			"single interval contains",
			NewRange([]Interval{NewInterval("1.0.0", "2.0.0", true, false)}),
			"1.5.0",
			true,
		},
		{
			"single interval excludes below",
			NewRange([]Interval{NewInterval("1.0.0", "2.0.0", true, false)}),
			"0.9.0",
			false,
		},
		{
			"single interval excludes above",
			NewRange([]Interval{NewInterval("1.0.0", "2.0.0", true, false)}),
			"2.0.0",
			false,
		},
		{
			"multiple intervals (union)",
			NewRange([]Interval{
				NewInterval("1.0.0", "2.0.0", true, true),
				NewInterval("3.0.0", "4.0.0", true, true),
			}),
			"3.5.0",
			true,
		},
		{
			"gap between intervals",
			NewRange([]Interval{
				NewInterval("1.0.0", "2.0.0", true, true),
				NewInterval("3.0.0", "4.0.0", true, true),
			}),
			"2.5.0",
			false,
		},
		{
			"exclusion",
			&Range{
				Intervals:  []Interval{NewInterval("1.0.0", "3.0.0", true, true)},
				Exclusions: []string{"2.0.0"},
			},
			"2.0.0",
			false,
		},
		{
			"exclusion allows other versions",
			&Range{
				Intervals:  []Interval{NewInterval("1.0.0", "3.0.0", true, true)},
				Exclusions: []string{"2.0.0"},
			},
			"2.1.0",
			true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got := tt.r.Contains(tt.version)
			if got != tt.want {
				t.Errorf("Contains(%q) = %v, want %v", tt.version, got, tt.want)
			}
		})
	}
}

func TestRangeIsEmpty(t *testing.T) {
	tests := []struct {
		name string
		r    *Range
		want bool
	}{
		{"no intervals", &Range{}, true},
		{"empty intervals only", NewRange([]Interval{EmptyInterval()}), true},
		{"valid interval", NewRange([]Interval{NewInterval("1.0.0", "2.0.0", true, true)}), false},
		{"unbounded", Unbounded(), false},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got := tt.r.IsEmpty()
			if got != tt.want {
				t.Errorf("IsEmpty() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestRangeIsUnbounded(t *testing.T) {
	tests := []struct {
		name string
		r    *Range
		want bool
	}{
		{"unbounded", Unbounded(), true},
		{"bounded", NewRange([]Interval{NewInterval("1.0.0", "2.0.0", true, true)}), false},
		{
			"unbounded with exclusion",
			&Range{
				Intervals:  []Interval{UnboundedInterval()},
				Exclusions: []string{"1.0.0"},
			},
			false,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got := tt.r.IsUnbounded()
			if got != tt.want {
				t.Errorf("IsUnbounded() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestRangeExactVersion(t *testing.T) {
	tests := []struct {
		name        string
		rangeValue  *Range
		wantVersion string
		wantOK      bool
	}{
		{name: "nil range"},
		{name: "empty range", rangeValue: Empty()},
		{name: "unbounded range", rangeValue: Unbounded()},
		{name: "exact range", rangeValue: Exact("1.2.3"), wantVersion: "1.2.3", wantOK: true},
		{
			name: "scheme equivalent bounds",
			rangeValue: &Range{
				Intervals: []Interval{NewInterval("1.0", "1.0.0", true, true)},
				Scheme:    "pypi",
			},
			wantVersion: "1.0",
			wantOK:      true,
		},
		{
			name:       "exclusive bound",
			rangeValue: NewRange([]Interval{NewInterval("1.2.3", "1.2.3", true, false)}),
		},
		{
			name:       "bounded range",
			rangeValue: NewRange([]Interval{NewInterval("1.0.0", "2.0.0", true, true)}),
		},
		{
			name: "matching exclusion",
			rangeValue: &Range{
				Intervals:  []Interval{ExactInterval("1.2.3")},
				Exclusions: []string{"1.2.3"},
			},
		},
		{
			name: "unrelated exclusion",
			rangeValue: &Range{
				Intervals:  []Interval{ExactInterval("1.2.3")},
				Exclusions: []string{"2.0.0"},
			},
			wantVersion: "1.2.3",
			wantOK:      true,
		},
		{
			name: "multiple intervals",
			rangeValue: NewRange([]Interval{
				ExactInterval("1.2.3"),
				ExactInterval("2.0.0"),
			}),
		},
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			gotVersion, gotOK := test.rangeValue.ExactVersion()
			if gotVersion != test.wantVersion || gotOK != test.wantOK {
				t.Errorf("ExactVersion() = (%q, %v), want (%q, %v)",
					gotVersion, gotOK, test.wantVersion, test.wantOK)
			}
		})
	}
}

func TestRangeMinimumVersion(t *testing.T) {
	tests := []struct {
		name        string
		rangeValue  *Range
		wantVersion string
		wantOK      bool
	}{
		{name: "nil range"},
		{name: "empty range", rangeValue: Empty()},
		{name: "unbounded range", rangeValue: Unbounded()},
		{
			name:        "inclusive lower bound",
			rangeValue:  NewRange([]Interval{NewInterval("1.2.3", "2.0.0", true, false)}),
			wantVersion: "1.2.3",
			wantOK:      true,
		},
		{
			name:       "exclusive lower bound",
			rangeValue: NewRange([]Interval{NewInterval("1.2.3", "2.0.0", false, false)}),
		},
		{
			name: "excluded lower bound",
			rangeValue: &Range{
				Intervals:  []Interval{NewInterval("1.2.3", "2.0.0", true, false)},
				Exclusions: []string{"1.2.3"},
			},
		},
		{
			name: "excluded exact interval before included interval",
			rangeValue: &Range{
				Intervals: []Interval{
					ExactInterval("1.0.0"),
					ExactInterval("2.0.0"),
				},
				Exclusions: []string{"1.0.0"},
			},
			wantVersion: "2.0.0",
			wantOK:      true,
		},
		{
			name: "unsorted intervals",
			rangeValue: NewRange([]Interval{
				ExactInterval("2.0.0"),
				ExactInterval("1.0.0"),
			}),
			wantVersion: "1.0.0",
			wantOK:      true,
		},
		{
			name: "equivalent inclusive and exclusive bounds",
			rangeValue: NewRange([]Interval{
				NewInterval("1.0.0", "2.0.0", false, false),
				NewInterval("1.0.0", "1.5.0", true, false),
			}),
			wantVersion: "1.0.0",
			wantOK:      true,
		},
		{
			name: "scheme equivalent bounds",
			rangeValue: &Range{
				Intervals: []Interval{
					ExactInterval("2.0"),
					ExactInterval("1.0.0"),
				},
				Scheme: "pypi",
			},
			wantVersion: "1.0.0",
			wantOK:      true,
		},
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			gotVersion, gotOK := test.rangeValue.MinimumVersion()
			if gotVersion != test.wantVersion || gotOK != test.wantOK {
				t.Errorf("MinimumVersion() = (%q, %v), want (%q, %v)",
					gotVersion, gotOK, test.wantVersion, test.wantOK)
			}
		})
	}
}

func TestRangeMinimumVersionFromNativeConstraint(t *testing.T) {
	tests := []struct {
		constraint  string
		scheme      string
		wantVersion string
		wantOK      bool
	}{
		{constraint: "^1.2.3", scheme: "npm", wantVersion: "1.2.3", wantOK: true},
		{constraint: "1.2.3 || 2.0.0", scheme: "npm", wantVersion: "1.2.3", wantOK: true},
		{constraint: "<3", scheme: "npm"},
		{constraint: ">=1.0.0,!=1.0.0", scheme: "pypi"},
	}

	for _, test := range tests {
		t.Run(test.scheme+" "+test.constraint, func(t *testing.T) {
			rangeValue, err := ParseNative(test.constraint, test.scheme)
			if err != nil {
				t.Fatal(err)
			}
			gotVersion, gotOK := rangeValue.MinimumVersion()
			if gotVersion != test.wantVersion || gotOK != test.wantOK {
				t.Errorf("MinimumVersion() = (%q, %v), want (%q, %v)",
					gotVersion, gotOK, test.wantVersion, test.wantOK)
			}
		})
	}
}

func TestRangeUnion(t *testing.T) {
	tests := []struct {
		name    string
		r1      *Range
		r2      *Range
		version string
		want    bool
	}{
		{
			"union of non-overlapping",
			NewRange([]Interval{NewInterval("1.0.0", "2.0.0", true, true)}),
			NewRange([]Interval{NewInterval("3.0.0", "4.0.0", true, true)}),
			"3.5.0",
			true,
		},
		{
			"union of overlapping",
			NewRange([]Interval{NewInterval("1.0.0", "3.0.0", true, true)}),
			NewRange([]Interval{NewInterval("2.0.0", "4.0.0", true, true)}),
			"3.5.0",
			true,
		},
		{
			"union preserves first range",
			NewRange([]Interval{NewInterval("1.0.0", "2.0.0", true, true)}),
			NewRange([]Interval{NewInterval("3.0.0", "4.0.0", true, true)}),
			"1.5.0",
			true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result := tt.r1.Union(tt.r2)
			got := result.Contains(tt.version)
			if got != tt.want {
				t.Errorf("Union().Contains(%q) = %v, want %v", tt.version, got, tt.want)
			}
		})
	}
}

func TestRangeIntersect(t *testing.T) {
	tests := []struct {
		name    string
		r1      *Range
		r2      *Range
		version string
		want    bool
	}{
		{
			"intersection of overlapping",
			NewRange([]Interval{NewInterval("1.0.0", "3.0.0", true, true)}),
			NewRange([]Interval{NewInterval("2.0.0", "4.0.0", true, true)}),
			"2.5.0",
			true,
		},
		{
			"intersection excludes non-overlap from first",
			NewRange([]Interval{NewInterval("1.0.0", "3.0.0", true, true)}),
			NewRange([]Interval{NewInterval("2.0.0", "4.0.0", true, true)}),
			"1.5.0",
			false,
		},
		{
			"intersection excludes non-overlap from second",
			NewRange([]Interval{NewInterval("1.0.0", "3.0.0", true, true)}),
			NewRange([]Interval{NewInterval("2.0.0", "4.0.0", true, true)}),
			"3.5.0",
			false,
		},
		{
			"non-overlapping produces empty",
			NewRange([]Interval{NewInterval("1.0.0", "2.0.0", true, true)}),
			NewRange([]Interval{NewInterval("3.0.0", "4.0.0", true, true)}),
			"1.5.0",
			false,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result := tt.r1.Intersect(tt.r2)
			got := result.Contains(tt.version)
			if got != tt.want {
				t.Errorf("Intersect().Contains(%q) = %v, want %v", tt.version, got, tt.want)
			}
		})
	}
}

func TestRangeExclude(t *testing.T) {
	r := Unbounded().Exclude("1.5.0")

	if !r.Contains("1.0.0") {
		t.Error("should contain 1.0.0")
	}
	if r.Contains("1.5.0") {
		t.Error("should not contain excluded 1.5.0")
	}
	if !r.Contains("2.0.0") {
		t.Error("should contain 2.0.0")
	}
}

func TestRangeExcludePreservesRawConstraints(t *testing.T) {
	original, err := ParseNative(">=1.0, <2.0", "gem")
	if err != nil {
		t.Fatal(err)
	}
	if len(original.RawConstraints) == 0 {
		t.Fatal("test precondition: native range should carry raw constraints")
	}

	excluded := original.Exclude("1.5")
	if excluded.Contains("1.5") {
		t.Error("excluded version should not be contained")
	}
	if len(excluded.RawConstraints) != len(original.RawConstraints) {
		t.Errorf("Exclude dropped RawConstraints: got %d, want %d", len(excluded.RawConstraints), len(original.RawConstraints))
	}

	serialized := ToVersString(excluded, "gem")
	roundTripped, err := Parse(serialized)
	if err != nil {
		t.Fatalf("Parse(%q): %v", serialized, err)
	}
	if roundTripped.Contains("1.5") || !roundTripped.Contains("1.4") || roundTripped.Contains("2.0") {
		t.Errorf("serialized exclusion did not round-trip: %q", serialized)
	}
}

func TestRangeExcludeIgnoresIrrelevantVersion(t *testing.T) {
	original, err := Parse("vers:npm/>=1.0.0|<2.0.0")
	if err != nil {
		t.Fatal(err)
	}

	unchanged := original.Exclude("3.0.0")
	if len(unchanged.Exclusions) != 0 {
		t.Errorf("Exclude added an irrelevant version: %v", unchanged.Exclusions)
	}
	if got, want := ToVersString(unchanged, "npm"), ToVersString(original, "npm"); got != want {
		t.Errorf("Exclude changed serialization for a version outside the range: %q vs %q", got, want)
	}

	stillExcluded := original.Exclude("1.5.0").Exclude("1.5.0")
	if len(stillExcluded.Exclusions) != 1 {
		t.Errorf("Exclude added a duplicate exclusion: %v", stillExcluded.Exclusions)
	}
}

func TestRangeUnionExclusionRetention(t *testing.T) {
	base, _ := Parse("vers:npm/>=1.0.0")
	excluded := base.Exclude("1.5.0")
	later, _ := Parse("vers:npm/>=2.0.0")

	if excluded.Union(later).Contains("1.5.0") {
		t.Error("Union should keep an exclusion the other operand does not contain")
	}
	if later.Union(excluded).Contains("1.5.0") {
		t.Error("Union should keep an exclusion the other operand does not contain (reversed)")
	}

	serialized := ToVersString(excluded.Union(later), "npm")
	roundTripped, err := Parse(serialized)
	if err != nil {
		t.Fatalf("Parse(%q): %v", serialized, err)
	}
	if roundTripped.Contains("1.5.0") {
		t.Errorf("serialized union lost the exclusion: %q", serialized)
	}

	covering, _ := Parse("vers:npm/>=1.4.0")
	if !excluded.Union(covering).Contains("1.5.0") {
		t.Error("Union should drop an exclusion the other operand contains")
	}
	if !covering.Union(excluded).Contains("1.5.0") {
		t.Error("Union should drop an exclusion the other operand contains (reversed)")
	}
}

func TestRangeUnionInheritsScheme(t *testing.T) {
	generic := NewRange([]Interval{GreaterThanInterval("1.0.dev1", true)})
	typed, _ := Parse("vers:pypi/<2.0")

	if got := generic.Union(typed).Scheme; got != "pypi" {
		t.Errorf("Union scheme = %q, want pypi", got)
	}
	if got := typed.Union(generic).Scheme; got != "pypi" {
		t.Errorf("Union scheme (reversed) = %q, want pypi", got)
	}
	if got := generic.Intersect(typed).Scheme; got != "pypi" {
		t.Errorf("Intersect scheme = %q, want pypi", got)
	}
	if got := typed.Intersect(generic).Scheme; got != "pypi" {
		t.Errorf("Intersect scheme (reversed) = %q, want pypi", got)
	}

	typedEmpty, _ := Parse("vers:pypi/")
	if got := typedEmpty.Union(generic).Scheme; got != "pypi" {
		t.Errorf("Union with typed empty operand scheme = %q, want pypi", got)
	}
	if got := generic.Union(typedEmpty).Scheme; got != "pypi" {
		t.Errorf("Union with typed empty operand (reversed) scheme = %q, want pypi", got)
	}
}

func TestRangeAlgebraDedupsEquivalentExclusions(t *testing.T) {
	left, _ := Parse("vers:semver/>=1.0.0")
	right, _ := Parse("vers:semver/>=1.0.0")
	left = left.Exclude("1.5")
	right = right.Exclude("1.5.0")

	if got := left.Union(right).Exclusions; len(got) != 1 {
		t.Errorf("Union exclusions = %v, want one entry", got)
	}
	if got := left.Intersect(right).Exclusions; len(got) != 1 {
		t.Errorf("Intersect exclusions = %v, want one entry", got)
	}
}

func TestRangeString(t *testing.T) {
	tests := []struct {
		name string
		r    *Range
		want string
	}{
		{"empty", &Range{}, "empty"},
		{"unbounded", Unbounded(), "*"},
		{
			"single interval",
			NewRange([]Interval{NewInterval("1.0.0", "2.0.0", true, false)}),
			"[1.0.0,2.0.0)",
		},
		{
			"multiple intervals",
			NewRange([]Interval{
				NewInterval("1.0.0", "2.0.0", true, true),
				NewInterval("3.0.0", "4.0.0", true, true),
			}),
			"[1.0.0,2.0.0] | [3.0.0,4.0.0]",
		},
		{
			"with exclusion",
			&Range{
				Intervals:  []Interval{NewInterval("1.0.0", "3.0.0", true, true)},
				Exclusions: []string{"2.0.0"},
			},
			"[1.0.0,3.0.0] excluding 2.0.0",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got := tt.r.String()
			if got != tt.want {
				t.Errorf("String() = %q, want %q", got, tt.want)
			}
		})
	}
}

func TestExact(t *testing.T) {
	r := Exact("1.2.3")

	if !r.Contains("1.2.3") {
		t.Error("Exact should contain its version")
	}
	if r.Contains("1.2.4") {
		t.Error("Exact should not contain other versions")
	}
}

func TestUnbounded(t *testing.T) {
	r := Unbounded()

	if !r.Contains("0.0.0") {
		t.Error("Unbounded should contain any version")
	}
	if !r.Contains("999.999.999") {
		t.Error("Unbounded should contain any version")
	}
	if !r.IsUnbounded() {
		t.Error("IsUnbounded() should return true")
	}
}