Merge pull request #82 from hedgehogqa/allow-autogen-config

Allow AutogenConfig to be received as a parameter for generic generators

Author: AlexeyRaga

.gitignore

@@ -51,4 +51,5 @@ Thumbs.db
 paket-files
 
 # Visual Studio cache/options directory
-.vs/
+.vs/
+.idea/

README.md

@@ -205,6 +205,28 @@ let! myVal =
   |> GenX.autoWith<MyType>
 ```
 
+**Register generators for generic types in `AutoGenConfig`:**
+
+```f#
+// An example of a generic type
+type Maybe<'a> = Just of 'a | Nothing
+
+// a type containing generators for generic types
+// methods should return Gen<_> and are allowed to take Gen<_> and AutoGenConfig as parameters
+type GenericGenerators =
+  // Generator for Maybe<'a>
+  static member MaybeGen<'a>(valueGen : Gen<'a>) : Gen<Maybe<'a>> =
+     Gen.frequency [
+        1, Gen.constant None
+        8, valueGen
+      ]
+     
+let! myVal =
+  GenX.defaults
+  |> AutoGenConfig.addGenerators<GenericGenerators>
+  |> GenX.autoWith<Maybe<int>>
+```
+
 If you’re not happy with the auto-gen defaults, you can of course create your own generator that calls `GenX.autoWith` with your chosen config and use that everywhere.
 
 Deployment checklist

src/Hedgehog.Experimental.CSharp.Tests/GenericGenTests.cs

@@ -1,5 +1,6 @@
 using System.Linq;
 using System;
+using System.Collections.Immutable;
 using Xunit;
 using static Hedgehog.Linq.Property;
 
@@ -55,6 +56,12 @@ public static Gen<Maybe<T>> AlwaysJust<T>(Gen<T> gen) =>
 
   public static Gen<Either<TLeft, TRight>> AlwaysLeft<TLeft, TRight>(Gen<TRight> genB, Gen<TLeft> genA) =>
     genA.Select(Either<TLeft, TRight> (value) => new Either<TLeft, TRight>.Left(value));
+
+  // Generator for ImmutableList<T> that uses AutoGenConfig's seqRange
+  public static Gen<ImmutableList<T>> ImmutableListGen<T>(AutoGenConfig config, Gen<T> genItem) =>
+    genItem
+      .List(config.GetCollectionRange())
+      .Select(ImmutableList.CreateRange);
 }
 
 public class GenericGenTests
@@ -136,4 +143,25 @@ public void ShouldGenerateOuterClassWithGenericTypeInside()
       };
     prop.Check();
   }
+
+  [Fact]
+  public void ShouldGenerateImmutableListUsingAutoGenConfigParameter()
+  {
+    var config = GenX.defaults
+      .WithCollectionRange(Range.FromValue(7))
+      .WithGenerators<GenericTestGenerators>();
+
+    // The ImmutableListGen<int> will be called with config and Gen<int>
+    // This demonstrates that generators can receive AutoGenConfig to access configuration
+    var prop = from x in ForAll(GenX.autoWith<ImmutableList<int>>(config))
+               select x.Count == 7;
+
+    prop.Check();
+
+    // Also test with a different type to verify generics work
+    var propString = from x in ForAll(GenX.autoWith<ImmutableList<string>>(config))
+                     select x.Count == 7;
+
+    propString.Check();
+  }
 }

src/Hedgehog.Experimental.Tests/AutoGenConfigTests.fs

@@ -45,3 +45,59 @@ let ``merging AutoGenConfig overrides values``() =
   }
 
   Property.check property
+
+type CustomType = { Value: int; Items: string list }
+
+type CustomGenerators =
+  // Generator that uses AutoGenConfig to access seqRange
+  static member CustomTypeGen(config: AutoGenConfig) : Gen<CustomType> = gen {
+    let! value = Gen.int32 (Range.exponentialBounded())
+    let! items = Gen.string (Range.linear 1 5) Gen.alpha |> Gen.list (AutoGenConfig.seqRange config)
+    return { Value = value; Items = items }
+  }
+
+  // Generator that takes both AutoGenConfig and Gen<_> parameters
+  static member CustomTypeWithGen(config: AutoGenConfig, genValue: Gen<int>) : Gen<CustomType> = gen {
+    let! value = genValue
+    let! items = Gen.string (Range.linear 1 5) Gen.alpha |> Gen.list (AutoGenConfig.seqRange config)
+    return { Value = value; Items = items }
+  }
+
+[<Fact>]
+let ``addGenerators supports methods with AutoGenConfig parameter``() =
+  let customConfig =
+    GenX.defaults
+    |> AutoGenConfig.setSeqRange (Range.constant 3 3)
+    |> AutoGenConfig.addGenerators<CustomGenerators>
+
+  // Create the generator and sample a value to ensure it works
+  let gen = customConfig |> GenX.autoWith<CustomType>
+  let sample = Gen.sample 0 1 gen |> Seq.head
+  test <@ sample.Items.Length = 3 @>
+
+open System.Collections.Immutable
+
+type ImmutableListGenerators =
+  // Generic generator for ImmutableList<T> that uses AutoGenConfig's seqRange
+  static member ImmutableListGen<'T>(config: AutoGenConfig, genItem: Gen<'T>) : Gen<ImmutableList<'T>> = gen {
+    let! items = genItem |> Gen.list (AutoGenConfig.seqRange config)
+    return items |> ImmutableList.CreateRange
+  }
+
+[<Fact>]
+let ``addGenerators supports generic methods with AutoGenConfig and Gen parameters``() =
+  let customConfig =
+    GenX.defaults
+    |> AutoGenConfig.setSeqRange (Range.constant 5 5)
+    |> AutoGenConfig.addGenerators<ImmutableListGenerators>
+
+  // The ImmutableListGen<int> will be called with config and Gen<int>
+  // This demonstrates that generic generators work with both AutoGenConfig and Gen<T> parameters
+  let gen = customConfig |> GenX.autoWith<ImmutableList<int>>
+  let sample = Gen.sample 0 1 gen |> Seq.head
+  test <@ sample.Count = 5 @>
+
+  // Also test with a different type to verify generics work
+  let genString = customConfig |> GenX.autoWith<ImmutableList<string>>
+  let sampleString = Gen.sample 0 1 genString |> Seq.head
+  test <@ sampleString.Count = 5 @>

src/Hedgehog.Experimental/AutoGenConfig.fs

@@ -48,28 +48,36 @@ module AutoGenConfig =
   /// The type is expected to have static methods that return Gen<_>.
   /// These methods can have parameters which are required to be of type Gen<_>.
   let addGenerators<'a> (config: AutoGenConfig) =
-      let isGen (t: Type) =
-          t.IsGenericType && t.GetGenericTypeDefinition() = typedefof<Gen<_>>
+      let getGenType (t: Type) =
+          if t.IsGenericType && t.GetGenericTypeDefinition() = typedefof<Gen<_>>
+            then Some (t.GetGenericArguments().[0])
+            else None
 
-      let tryUnwrapGenParameters (methodInfo: MethodInfo) : Option<Type[]> =
+      let getAutoGenConfigType (t: Type) =
+          if t = typeof<AutoGenConfig>
+            then Some t
+            else None
+
+      let tryUnwrapParameters (methodInfo: MethodInfo) : Option<Type[]> =
           methodInfo.GetParameters()
           |> Array.fold (fun acc param ->
-              match acc, isGen param.ParameterType with
-              | Some types, true ->
-                  Some (Array.append types [| param.ParameterType.GetGenericArguments().[0] |])
-              | _ -> None
+              match acc with
+              | None -> None
+              | Some types ->
+                  getGenType param.ParameterType
+                    |> Option.orElseWith (fun () -> getAutoGenConfigType param.ParameterType)
+                    |> Option.map (fun t -> Array.append types [| t |])
           ) (Some [||])
 
       typeof<'a>.GetMethods(BindingFlags.Static ||| BindingFlags.Public)
       |> Seq.choose (fun methodInfo ->
-          match isGen methodInfo.ReturnType, tryUnwrapGenParameters methodInfo with
-          | true, Some typeArray ->
-              let targetType = methodInfo.ReturnType.GetGenericArguments().[0]
-              let factory: Type[] -> obj[] -> obj = fun types gens ->
+          match getGenType methodInfo.ReturnType, tryUnwrapParameters methodInfo with
+          | Some targetType, Some typeArray ->
+              let factory: Type[] -> obj[] -> obj = fun types args ->
                   let methodToCall =
                       if Array.isEmpty types then methodInfo
                       else methodInfo.MakeGenericMethod(types)
-                  methodToCall.Invoke(null, gens)
+                  methodToCall.Invoke(null, args)
               Some (targetType, typeArray, factory)
           | _ -> None)
       |> Seq.fold (fun cfg (targetType, typeArray, factory) ->

src/Hedgehog.Experimental/GenExtensions.fs

@@ -18,6 +18,10 @@ type GenExtraExtensions() =
   static member WithGenerators<'T>(self : AutoGenConfig) =
     self |> AutoGenConfig.addGenerators<'T>
 
+  [<Extension>]
+  static member GetCollectionRange(self : AutoGenConfig) =
+    AutoGenConfig.seqRange self
+
   [<Extension>]
   static member WithCollectionRange(self : AutoGenConfig, range : Range<int>) =
     self |> AutoGenConfig.setSeqRange range

src/Hedgehog.Experimental/GenX.fs

@@ -368,7 +368,7 @@ module GenX =
             array.SetValue(en.Current, currentIndices)
         | currentLength :: remainingLengths ->
             for i in 0..currentLength - 1 do
-              currentIndices.[currentDimensionIndex] <- i
+              currentIndices[currentDimensionIndex] <- i
               loop (currentDimensionIndex + 1) remainingLengths
       loop 0 lengths
       array
@@ -385,11 +385,15 @@ module GenX =
     let addGenMsg = "You can use 'GenX.defaults |> AutoGenConfig.addGenerator myGen |> GenX.autoWith' to generate types not inherently supported by GenX.auto."
     let unsupportedTypeException = NotSupportedException (sprintf "Unable to auto-generate %s. %s" typeof<'a>.FullName addGenMsg)
 
+    // Prevent auto-generating AutoGenConfig itself - it should only be passed as a parameter
+    if typeof<'a> = typeof<AutoGenConfig> then
+      raise (NotSupportedException "Cannot auto-generate AutoGenConfig type. It should be provided as a parameter to generator methods.")
+
     let genPoco (shape: ShapePoco<'a>) =
       let bestCtor =
         shape.Constructors
-        |> Seq.filter (fun c -> c.IsPublic)
-        |> Seq.sortBy (fun c -> c.Arity)
+        |> Seq.filter _.IsPublic
+        |> Seq.sortBy _.Arity
         |> Seq.tryHead
 
       match bestCtor with
@@ -458,10 +462,10 @@ module GenX =
                   if arg.IsGenericParameter then
                     typeArgs
                     |> Array.tryFind (fun p -> p.argTypeDefinition.Name = arg.Name)
-                    |> Option.map (_.argType)
+                    |> Option.map _.argType
                     |> Option.defaultWith (fun _ -> raise unsupportedTypeException)
                   else arg)
-          {| genericTypes = typeArgs |> Array.map (_.argType); argumentTypes = argTypes |}
+          {| genericTypes = typeArgs |> Array.map _.argType; argumentTypes = argTypes |}
 
         | _ -> {| genericTypes = Array.empty; argumentTypes = args |}
 
@@ -470,10 +474,15 @@ module GenX =
       let targetArgs =
         factoryArgs.argumentTypes
         |> Array.map (fun t ->
-          let ts = TypeShape.Create(t)
-          ts.Accept { new ITypeVisitor<obj> with
-            member __.Visit<'b> () = autoInner<'b> config recursionDepths |> box
-          })
+          // Check if this is AutoGenConfig type
+          if t = typeof<AutoGenConfig> then
+            box config
+          else
+            // Otherwise, generate a value for this type
+            let ts = TypeShape.Create(t)
+            ts.Accept { new ITypeVisitor<obj> with
+              member __.Visit<'b> () = autoInner<'b> config recursionDepths |> box
+            })
 
       let resGen = factory factoryArgs.genericTypes targetArgs
       resGen |> unbox<Gen<'a>>
@@ -560,8 +569,8 @@ module GenX =
                  |> ListGen.traverse memberSetterGenerator)
             gen {
               let! caseIdx = Gen.integral <| Range.constant 0 (cases.Length - 1)
-              let! fs = cases.[caseIdx]
-              return fs |> List.fold (|>) (shape.UnionCases.[caseIdx].CreateUninitialized ())
+              let! fs = cases[caseIdx]
+              return fs |> List.fold (|>) (shape.UnionCases[caseIdx].CreateUninitialized ())
             }
 
         | Shape.Enum _ ->

src/Hedgehog.Experimental/GeneratorCollection.fs

@@ -4,7 +4,7 @@ open System
 open System.Collections.Immutable
 
 // A generator factory which can be backed by a generic method.
-// It takes an array of genetic type parameters, and an array of arguments to create the generator.
+// It takes an array of genetic type parameters and an array of arguments to create the generator.
 type private GeneratorFactory = Type[] -> obj[] -> obj
 
 [<Struct>]