Improve Merge tests

src/GqlPlus.Verifier/Merging/MergeCategories.cs

@@ -11,5 +11,5 @@ public override bool CanMerge(IEnumerable<CategoryDeclAst> items)
       && items.CanMerge(item => item.Option);
 
   protected override string ItemMatchKey(CategoryDeclAst item)
-    => $"{item.Output}{item.Modifiers.AsString()}-{item.Option}";
+    => $"{item.Output}{item.Modifiers.AsString()}~{item.Option}";
 }

src/GqlPlus.Verifier/Merging/MergeEnumMembers.cs

@@ -5,5 +5,6 @@ namespace GqlPlus.Verifier.Merging;
 internal class MergeEnumMembers
   : AliasedMerger<EnumMemberAst>
 {
-  protected override string ItemMatchKey(EnumMemberAst item) => item.Name;
+  protected override string ItemMatchKey(EnumMemberAst item)
+    => item.Name;
 }

src/GqlPlus.Verifier/Merging/MergeEnums.cs

@@ -4,7 +4,7 @@ namespace GqlPlus.Verifier.Merging;
 
 internal class MergeEnums(
   IMerge<EnumMemberAst> enumMembers
-) : AliasedAllMerger<AstType, EnumDeclAst>, IMergeAll<AstType>
+) : TypedMerger<AstType, EnumDeclAst, string>, IMergeAll<AstType>
 {
   protected override string ItemMatchKey(EnumDeclAst item)
     => item.Parent ?? "";

src/GqlPlus.Verifier/Merging/MergeScalarMembers.cs

@@ -8,7 +8,7 @@ internal class MergeScalarMembers
   protected override string ItemGroupKey(ScalarMemberAst item) => item.Member;
 
   protected override string ItemMatchKey(ScalarMemberAst item)
-    => $"{item.Excludes}-{item.EnumType}";
+    => $"{item.Excludes}~{item.EnumType}";
 
   protected override ScalarMemberAst MergeGroup(IEnumerable<ScalarMemberAst> group)
     => group.First();

src/GqlPlus.Verifier/Merging/MergeScalars.cs

@@ -1,14 +1,15 @@
-using GqlPlus.Verifier.Ast.Schema;
+using GqlPlus.Verifier.Ast;
+using GqlPlus.Verifier.Ast.Schema;
 
 namespace GqlPlus.Verifier.Merging;
 
 internal class MergeScalars<TMember>(
   IMerge<TMember> members
-) : AliasedAllMerger<AstScalar, AstScalar<TMember>>
+) : TypedMerger<AstScalar, AstScalar<TMember>, string>
   where TMember : IAstScalarItem
 {
   protected override string ItemMatchKey(AstScalar<TMember> item)
-    => item.Kind.ToString();
+    => item.Kind.ToString() + item.Parent.Prefixed("~");
 
   public override bool CanMerge(IEnumerable<AstScalar<TMember>> items)
     => base.CanMerge(items)

src/GqlPlus.Verifier/Merging/ObjectsMerger.cs

@@ -7,7 +7,7 @@ internal class ObjectsMerger<TObject, TField, TReference>(
   IMerge<TypeParameterAst> typeParameters,
   IMerge<AlternateAst<TReference>> alternates,
   IMerge<TField> fields
-) : AliasedAllMerger<AstType, TObject>
+) : TypedMerger<AstType, TObject, TReference>
   where TObject : AstObject<TField, TReference>
   where TField : AstField<TReference>, IAstDescribed
   where TReference : AstReference<TReference>

src/GqlPlus.Verifier/Merging/TypedMerger.cs

@@ -0,0 +1,11 @@
+using GqlPlus.Verifier.Ast.Schema;
+
+namespace GqlPlus.Verifier.Merging;
+
+internal abstract class TypedMerger<TBase, TType, TParent>
+  : AliasedAllMerger<TBase, TType>
+  where TBase : AstAliased
+  where TType : AstType<TParent>, TBase
+  where TParent : IEquatable<TParent>
+{
+}

test/GqlPlus.Verifier.ClassTests/Merging/MergeEnumsTests.cs

@@ -5,16 +5,8 @@
 namespace GqlPlus.Verifier.Merging;
 
 public class MergeEnumsTests
-  : TestAliased<EnumDeclAst>
+  : TestTyped<AstType, EnumDeclAst, string>
 {
-  [Theory, RepeatData(Repeats)]
-  public void CanMerge_TwoItemsSameExtends_ReturnsTrue(string name)
-    => CanMerge_True([new EnumDeclAst(AstNulls.At, name), new EnumDeclAst(AstNulls.At, name)]);
-
-  [Theory, RepeatData(Repeats)]
-  public void CanMerge_TwoItemsDifferentExtends_ReturnsFalse(string name, string parent)
-    => CanMerge_False([new EnumDeclAst(AstNulls.At, name) { Parent = parent }, new EnumDeclAst(AstNulls.At, name)]);
-
   [Theory, RepeatData(Repeats)]
   public void CanMerge_TwoItemsValuesCantMerge_ReturnsFalse(string name, string[] values)
   {
@@ -47,8 +39,10 @@ public MergeEnumsTests()
     _merger = new(_enumMembers);
   }
 
-  internal override GroupsMerger<EnumDeclAst> MergerGroups => _merger;
+  internal override TypedMerger<AstType, EnumDeclAst, string> MergerTyped => _merger;
 
-  protected override EnumDeclAst MakeAliased(string name, string[] aliases, string description = "")
-    => new(AstNulls.At, name, description) { Aliases = aliases };
+  protected override EnumDeclAst MakeTyped(string name, string description = "")
+    => new(AstNulls.At, name, description);
+  protected override string MakeParent(string parent)
+    => parent;
 }

test/GqlPlus.Verifier.ClassTests/Merging/MergeScalarAstEnumsTests.cs

@@ -0,0 +1,14 @@
+using GqlPlus.Verifier.Ast;
+using GqlPlus.Verifier.Ast.Schema;
+
+namespace GqlPlus.Verifier.Merging;
+
+public class MergeScalarAstEnumsTests
+  : TestScalarAsts<ScalarMemberAst, string>
+{
+  protected override ScalarMemberAst[] MakeItems(string input)
+    => input.ScalarMembers();
+
+  protected override AstScalar<ScalarMemberAst> MakeTyped(string name, string description = "")
+    => new(AstNulls.At, name, description, ScalarKind.Enum);
+}

test/GqlPlus.Verifier.ClassTests/Merging/MergeScalarAstNumbersTests.cs

@@ -1,58 +1,14 @@
 using GqlPlus.Verifier.Ast;
 using GqlPlus.Verifier.Ast.Schema;
-using NSubstitute;
 
 namespace GqlPlus.Verifier.Merging;
 
 public class MergeScalarAstNumbersTests
-  : TestDescriptions<AstScalar<ScalarRangeAst>>
+  : TestScalarAsts<ScalarRangeAst, ScalarRangeInput>
 {
-  [Theory, RepeatData(Repeats)]
-  public void CanMerge_TwoItemsSameKinds_ReturnsTrue(string name)
-  {
-    var items = new[] { MakeDescribed(name), MakeDescribed(name) };
+  protected override ScalarRangeAst[] MakeItems(ScalarRangeInput input)
+    => input.ScalarRange();
 
-    var result = _merger.CanMerge(items);
-
-    result.Should().BeTrue();
-  }
-
-  [Theory, RepeatData(Repeats)]
-  public void CanMerge_TwoItemsDifferentKinds_ReturnsFalse(string name)
-  {
-    var items = new[] { MakeDescribed(name) with { Kind = ScalarKind.String }, MakeDescribed(name) };
-
-    var result = _merger.CanMerge(items);
-
-    result.Should().BeFalse();
-  }
-
-  [Theory, RepeatData(Repeats)]
-  public void CanMerge_TwoItemsRangesCantMerge_ReturnsFalse(string name, ScalarRangeInput range)
-  {
-    var items = new[] {
-      MakeDescribed(name) with { Items = range.ScalarRange() },
-      MakeDescribed(name) with { Items = range.ScalarRange() },
-    };
-    _ranges.CanMerge([]).ReturnsForAnyArgs(false);
-
-    var result = _merger.CanMerge(items);
-
-    result.Should().BeFalse();
-  }
-
-  private readonly IMerge<ScalarRangeAst> _ranges;
-  private readonly MergeScalars<ScalarRangeAst> _merger;
-
-  public MergeScalarAstNumbersTests()
-  {
-    _ranges = Merger<ScalarRangeAst>();
-
-    _merger = new(_ranges);
-  }
-
-  internal override GroupsMerger<AstScalar<ScalarRangeAst>> MergerGroups => _merger;
-
-  protected override AstScalar<ScalarRangeAst> MakeDescribed(string name, string description = "")
+  protected override AstScalar<ScalarRangeAst> MakeTyped(string name, string description = "")
     => new(AstNulls.At, name, description, ScalarKind.Number);
 }

test/GqlPlus.Verifier.ClassTests/Merging/MergeScalarAstStringsTests.cs

@@ -1,58 +1,14 @@
 using GqlPlus.Verifier.Ast;
 using GqlPlus.Verifier.Ast.Schema;
-using NSubstitute;
 
 namespace GqlPlus.Verifier.Merging;
 
 public class MergeScalarAstStringsTests
-  : TestDescriptions<AstScalar<ScalarRegexAst>>
+  : TestScalarAsts<ScalarRegexAst, string>
 {
-  [Theory, RepeatData(Repeats)]
-  public void CanMerge_TwoItemsSameKinds_ReturnsTrue(string name)
-  {
-    var items = new[] { MakeDescribed(name), MakeDescribed(name) };
+  protected override ScalarRegexAst[] MakeItems(string input)
+    => input.ScalarRegexes();
 
-    var result = _merger.CanMerge(items);
-
-    result.Should().BeTrue();
-  }
-
-  [Theory, RepeatData(Repeats)]
-  public void CanMerge_TwoItemsDifferentKinds_ReturnsFalse(string name)
-  {
-    var items = new[] { MakeDescribed(name) with { Kind = ScalarKind.Number }, MakeDescribed(name) };
-
-    var result = _merger.CanMerge(items);
-
-    result.Should().BeFalse();
-  }
-
-  [Theory, RepeatData(Repeats)]
-  public void CanMerge_TwoItemsRegexesCantMerge_ReturnsFalse(string name, string regex)
-  {
-    var items = new[] {
-      MakeDescribed(name) with { Items = regex.ScalarRegexes() },
-      MakeDescribed(name) with { Items = regex.ScalarRegexes() },
-    };
-    _regexes.CanMerge([]).ReturnsForAnyArgs(false);
-
-    var result = _merger.CanMerge(items);
-
-    result.Should().BeFalse();
-  }
-
-  private readonly IMerge<ScalarRegexAst> _regexes;
-  private readonly MergeScalars<ScalarRegexAst> _merger;
-
-  public MergeScalarAstStringsTests()
-  {
-    _regexes = Merger<ScalarRegexAst>();
-
-    _merger = new(_regexes);
-  }
-
-  internal override GroupsMerger<AstScalar<ScalarRegexAst>> MergerGroups => _merger;
-
-  protected override AstScalar<ScalarRegexAst> MakeDescribed(string name, string description = "")
+  protected override AstScalar<ScalarRegexAst> MakeTyped(string name, string description = "")
     => new(AstNulls.At, name, description, ScalarKind.String);
 }

test/GqlPlus.Verifier.ClassTests/Merging/MergeScalarAstUnionsTests.cs

@@ -4,68 +4,10 @@
 namespace GqlPlus.Verifier.Merging;
 
 public class MergeScalarAstUnionsTests
-  : TestDescriptions<AstScalar<ScalarReferenceAst>>
+  : TestScalarAsts<ScalarReferenceAst, string>
 {
-  [Theory, RepeatData(Repeats)]
-  public void CanMerge_TwoItemsSameKinds_ReturnsTrue(string name)
-  {
-    var items = new[] { MakeDescribed(name), MakeDescribed(name) };
-
-    var result = _merger.CanMerge(items);
-
-    result.Should().BeTrue();
-  }
-
-  [Theory, RepeatData(Repeats)]
-  public void CanMerge_TwoItemsDifferentKinds_ReturnsFalse(string name)
-  {
-    var items = new[] { MakeDescribed(name) with { Kind = ScalarKind.String }, MakeDescribed(name) };
-
-    var result = _merger.CanMerge(items);
-
-    result.Should().BeFalse();
-  }
-
-  //[Theory, RepeatData(Repeats)]
-  //public void CanMerge_TwoItemsRangesCantMerge_ReturnsFalse(string name, RangeUnionInput range)
-  //{
-  //  var items = new[] {
-  //    MakeDescribed(name) with { Members = range.ScalarRanges() },
-  //    MakeDescribed(name) with { Members = range.ScalarRanges() },
-  //  };
-  //  _ranges.CanMerge([]).ReturnsForAnyArgs(false);
-
-  //  var result = _merger.CanMerge(items);
-
-  //  result.Should().BeFalse();
-  //}
-
-  //[Theory, RepeatData(Repeats)]
-  //public void CanMerge_TwoItemsRegexesCantMerge_ReturnsFalse(string name, string regex)
-  //{
-  //  var items = new[] {
-  //    MakeDescribed(name) with { Members = regex.ScalarRegexes() },
-  //    MakeDescribed(name) with { Members = regex.ScalarRegexes() },
-  //  };
-  //  _regexes.CanMerge([]).ReturnsForAnyArgs(false);
-
-  //  var result = _merger.CanMerge(items);
-
-  //  result.Should().BeFalse();
-  //}
-
-  private readonly IMerge<ScalarReferenceAst> _references;
-  private readonly MergeScalars<ScalarReferenceAst> _merger;
-
-  public MergeScalarAstUnionsTests()
-  {
-    _references = Merger<ScalarReferenceAst>();
-
-    _merger = new(_references);
-  }
-
-  internal override GroupsMerger<AstScalar<ScalarReferenceAst>> MergerGroups => _merger;
-
-  protected override AstScalar<ScalarReferenceAst> MakeDescribed(string name, string description = "")
+  protected override ScalarReferenceAst[] MakeItems(string input)
+    => input.ScalarReferences();
+  protected override AstScalar<ScalarReferenceAst> MakeTyped(string name, string description = "")
     => new(AstNulls.At, name, description, ScalarKind.Union);
 }

test/GqlPlus.Verifier.ClassTests/Merging/TestObjects.cs

@@ -5,24 +5,11 @@
 namespace GqlPlus.Verifier.Merging;
 
 public abstract class TestObjects<TObject, TField, TReference>
-  : TestAliased<TObject>
+  : TestTyped<AstType, TObject, TReference>
   where TObject : AstObject<TField, TReference>
   where TField : AstField<TReference>, IAstDescribed
   where TReference : AstReference<TReference>
 {
-  [Theory, RepeatData(Repeats)]
-  public void CanMerge_TwoItemsSameBaseType_ReturnsTrue(string name, string type)
-    => CanMerge_True([
-      MakeObject(name) with { Parent = MakeReference(type) },
-      MakeObject(name) with { Parent = MakeReference(type) }]);
-
-  [Theory, RepeatData(Repeats)]
-  public void CanMerge_TwoItemsDifferentTypes_ReturnsFalse(string name, string type1, string type2)
-    => CanMerge_False([
-      MakeObject(name) with { Parent = MakeReference(type1) },
-      MakeObject(name) with { Parent = MakeReference(type2) }],
-      type1 == type2);
-
   [Theory, RepeatData(Repeats)]
   public void CanMerge_TwoItemsTypeParametersCantMerge_ReturnsFalse(string name, string[] typeParameters)
   {
@@ -66,12 +53,14 @@ protected TestObjects()
   }
 
   internal abstract ObjectsMerger<TObject, TField, TReference> MergerObject { get; }
-  internal override GroupsMerger<TObject> MergerGroups => MergerObject;
+  internal override TypedMerger<AstType, TObject, TReference> MergerTyped => MergerObject;
 
   protected abstract TObject MakeObject(string name, string description = "");
   protected abstract TField[] MakeFields(string field, string type);
   protected abstract TReference MakeReference(string type);
-  protected override TObject MakeAliased(string name, string[] aliases, string description = "")
-    => MakeObject(name, description) with { Aliases = aliases };
 
+  protected override TObject MakeTyped(string name, string description = "")
+    => MakeObject(name, description);
+  protected override TReference MakeParent(string parent)
+    => MakeReference(parent);
 }