public void CreateWithExpressionRequestReturnsCorrectResult(Type expected)
{
var expressionRequest = expected;
var context = new SpecimenContext(new Fixture());
var sut = new LambdaExpressionGenerator();
var result = sut.Create(expressionRequest, context);
Assert.IsType(expected, result);
}
private object Resolve(ParameterInfo p)
{
var context = new SpecimenContext(this.Fixture);
return(context.Resolve(p));
}
public void ExecuteIgnoresNotDbItemSpecimens(AddContentDbItemCommand sut, object specimen, SpecimenContext context)
{
Action action = () => sut.Execute(specimen, context);
action.ShouldNotThrow();
}
public static object Create(this ISpecimenBuilder specimenBuilder, Type type)
{
var context = new SpecimenContext(specimenBuilder);
return(context.Resolve(type));
}
public async Task Create_returns_finite_sequence(AsyncEnumerableSpecimenBuilder sut, SpecimenContext context)
{
var result = sut.Create(typeof(IAsyncEnumerable <int>), context) as IAsyncEnumerable <int>;
await foreach (var item in result !)
{
TestContext.WriteLine($"Item: {item}");
}
Assert.Pass();
}
public void Create_returns_instance_of_type_if_request_is_valid(AsyncEnumerableSpecimenBuilder sut, SpecimenContext context)
{
var result = sut.Create(typeof(IAsyncEnumerable <int>), context);
Assert.That(result, Is.InstanceOf <IAsyncEnumerable <int> >());
}
public void Create_returns_NoSpecimen_if_request_is_invalid(AsyncEnumerableSpecimenBuilder sut, SpecimenContext context)
{
var result = sut.Create(typeof(object), context);
Assert.That(result, Is.InstanceOf <NoSpecimen>());
}
public static object Create(this Fixture fixture, Type type)
{
var context = new SpecimenContext(fixture);
return(context.Resolve(type));
}
public void Create_returns_HttpClient_if_requested(HttpClientSpecimenBuilder sut, SpecimenContext context)
{
var result = sut.Create(typeof(HttpClient), context);
Assert.That(result, Is.InstanceOf <HttpClient>());
}
private object CreateFromType(Type request)
{
var specimenContext = new SpecimenContext(Fixture);
return(specimenContext.Resolve(request));
}
/// <summary>
/// Creates a specimen of the specified type using the owned
/// <see cref="ISpecimenBuilder"/>.
/// </summary>
/// <param name="type">The <see cref="Type"/> of the specimen to create.</param>
/// <returns>An instance of the specified <see cref="Type"/> created by the owned
/// <see cref="ISpecimenBuilder"/>.</returns>
protected object CreateSpecimen(Type type)
{
var context = new SpecimenContext(this.SpecimenBuilder);
return(context.Resolve(type));
}
private object GetNextValue(Type type)
{
var specimen = new SpecimenContext(AutoFixture).Resolve(type);
return(specimen);
}
public void InsertManyRandomRowsIntoManyRandomTables_UsingAutoFixture()
{
var testCaseResults = new List <TestInsertDeleteCaseResult>();
var typesToInsert = new List <Type>();
var randomSqlTableReferences = new List <SqlTableReference>();
var db = SqlConnectionProviders.AdventureWorksDb;
"Given a bunch of DB tables and CLR types that represent those tables"
._(() =>
{
randomSqlTableReferences = RandomTableSelector
.GetRandomSqlTableReferences(db, 400)
.OrderBy(x => x.SchemaName)
.ThenBy(x => x.TableName)
.ToList();
typesToInsert = Assembly
.GetAssembly(typeof(BusinessEntityContact))
.GetTypes()
.Where(x => !x.IsAnonymousType())
.Where(x => x.GetProperties().All(p => p.PropertyType != typeof(XElement)))
.Where(x => x.GetProperties().All(p => p.PropertyType != typeof(SqlHierarchyId)))
.Where(x => !x.Name.StartsWith("v"))
.Where(x => x.Namespace.Equals("UniqueDb.ConnectionProvider.Tests.DataGeneration.AdventureWorks"))
.ToList();
});
var fixture = new Fixture();
fixture.Inject(new SqlGeography());
"For each table in the DB"
._(() =>
{
foreach (var sqlTableReference in randomSqlTableReferences)
{
TestInsertDeleteCaseResult testCase = null;
var clrTypeForTable = typesToInsert.SingleOrDefault(t => t.Name.Equals(sqlTableReference.TableName));
"Create a test case result"
._(() =>
{
testCase = new TestInsertDeleteCaseResult()
{
SqlTableReference = sqlTableReference, ClrType = clrTypeForTable
};
testCaseResults.Add(testCase);
});
if (clrTypeForTable == null)
{
continue;
}
object clrObjectForSqlTable = null;
"Given a new, random instance of the CLR type representing the SqlTableReference"
._(() =>
{
var context = new SpecimenContext(fixture);
clrObjectForSqlTable = context.Resolve(new SeededRequest(clrTypeForTable, null));
});
"Try inserting into database"
._(() =>
{
try
{
db.Insert(clrObjectForSqlTable, sqlTableReference.TableName, sqlTableReference.SchemaName);
}
catch (Exception e)
{
testCase.AddInsertException(e);
}
});
"Try updating the database"
._(() =>
{
try
{
db.Update(clrObjectForSqlTable, null, sqlTableReference.TableName, sqlTableReference.SchemaName);
}
catch (Exception e)
{
testCase.AddUpdateException(e);
}
});
"Try deleting from database"
._(() =>
{
try
{
db.Delete(clrObjectForSqlTable, null, sqlTableReference.TableName, sqlTableReference.SchemaName);
}
catch (Exception e)
{
testCase.AddDeleteException(e);
}
});
testCase.WrapUp();
}
});
"Print out test results"
._(() =>
{
PrintSummary(testCaseResults);
PrintDetails(testCaseResults);
});
}
