public void CreatingAList()
{
var builderSetup = new BuilderSettings();
var products = new Builder(builderSetup).CreateListOfSize<Product>(10).Build();
// Note: The asserts here are intentionally verbose to show how NBuilder works
// It sets strings to their name plus their 1-based sequence number
Assert.That(products[0].Title, Is.EqualTo("Title1"));
Assert.That(products[1].Title, Is.EqualTo("Title2"));
Assert.That(products[2].Title, Is.EqualTo("Title3"));
Assert.That(products[3].Title, Is.EqualTo("Title4"));
Assert.That(products[4].Title, Is.EqualTo("Title5"));
Assert.That(products[5].Title, Is.EqualTo("Title6"));
Assert.That(products[6].Title, Is.EqualTo("Title7"));
Assert.That(products[7].Title, Is.EqualTo("Title8"));
Assert.That(products[8].Title, Is.EqualTo("Title9"));
Assert.That(products[9].Title, Is.EqualTo("Title10"));
// Ints are set to their 1-based sequence number
Assert.That(products[0].Id, Is.EqualTo(1));
// ... 2, 3, 4, 5, 6, 7, 8 ...
Assert.That(products[9].Id, Is.EqualTo(10));
// Any other numeric types are set to their 1-based sequence number
Assert.That(products[0].PriceBeforeTax, Is.EqualTo(1m));
// ... 2m, 3m, 4m, 5m, 6m, 7m, 8m ...
Assert.That(products[9].PriceBeforeTax, Is.EqualTo(10m));
}
public BuilderSettings DoSetup()
{
DbConfiguration.SetConfiguration(new IntegrationTestConfiguration());
using (var db = new ProductsDbContext())
{
db.Database.Delete();
}
BuilderSettings builderSettings = new BuilderSettings();
if (_setup)
return builderSettings;
_setup = true;
var productRepository = Dependency.Resolve<IProductRepository>();
var taxTypeRepository = Dependency.Resolve<ITaxTypeRepository>();
var categoryRepository = Dependency.Resolve<ICategoryRepository>();
builderSettings.SetCreatePersistenceMethod<Product>(productRepository.Create);
builderSettings.SetCreatePersistenceMethod<IList<Product>>(productRepository.CreateAll);
builderSettings.SetCreatePersistenceMethod<TaxType>(taxTypeRepository.Create);
builderSettings.SetCreatePersistenceMethod<IList<TaxType>>(taxTypeRepository.CreateAll);
builderSettings.SetCreatePersistenceMethod<Category>(categoryRepository.Create);
builderSettings.SetCreatePersistenceMethod<IList<Category>>(categoryRepository.CreateAll);
builderSettings.SetUpdatePersistenceMethod<Category>(categoryRepository.Save);
builderSettings.SetUpdatePersistenceMethod<IList<Category>>(categoryRepository.SaveAll);
return builderSettings;
}
public void SetUp()
{
var builderSetup = new BuilderSettings();
reflectionUtil = Substitute.For<IReflectionUtil>();
generator = Substitute.For<IRandomGenerator>();
propertyNamer = new RandomValuePropertyNamer(generator, reflectionUtil, false,builderSetup);
}
public void ShouldBeAbleToDisableAutomaticPropertyNaming()
{
var builderSetup = new BuilderSettings();
builderSetup.AutoNameProperties = false;
var obj = new Builder(builderSetup).CreateNew<MyClass>().Build();
Assert.That(obj.Int, Is.EqualTo(0));
}
internal FieldConverter(BuilderSettings settings)
{
var converter = settings.CustomFieldConverter ?? _fieldConverters[settings.FieldCasing];
_converter = settings.FieldArray == FieldArray.UseArraySyntax
? (s => converter(s) + "[]")
: converter;
}
internal QueryStringBuilder(BuilderSettings settings)
{
var propertyBuilder = new PropertyBuilder(settings);
var nullBuilder = new NullBuilder(settings);
var mixedArrayObjectBuilder = new MixedObjectArrayBuilder(settings, propertyBuilder);
var arrayBuilder = new ArrayBuilder(propertyBuilder);
_complexObjectBuilder = new ComplexObjectBuilder(settings, propertyBuilder, nullBuilder, mixedArrayObjectBuilder, arrayBuilder);
}
public void Just_the_date()
{
var builderSetup = new BuilderSettings();
var product = new Builder(builderSetup).CreateNew< Product>()
.With(x => x.Created = On.May.The14th)
.Build();
Assert.That(product.Created, Is.EqualTo(new DateTime(DateTime.Now.Year, 05, 14, 00, 00, 00)));
}
public void Do()
{
var builderSetup = new BuilderSettings();
new Builder(builderSetup)
.CreateListOfSize<Product>(10)
.All()
.WithLongTitles()
.Build();
}
public void ShouldChooseCorrectConstructor()
{
var builderSetup = new BuilderSettings();
var obj = Builder<MyClassWithConstructor>.CreateNew()
.WithConstructor(() => new MyClassWithConstructor(theInt, theFloat))
.Build();
Assert.That(obj.Int, Is.EqualTo(theInt));
Assert.That(obj.Float, Is.EqualTo(theFloat));
}
public void SetUp()
{
builderSettings = new BuilderSettings();
mocks = new MockRepository();
listBuilderImpl = mocks.DynamicMock<IListBuilderImpl<SimpleClass>>();
objectBuilder = mocks.StrictMock<IObjectBuilder<SimpleClass>>();
listBuilderImpl.Stub(x => x.Capacity).Return(2);
listBuilderImpl.Stub(x => x.BuilderSettings).Return(builderSettings);
objectBuilder.Stub(x => x.BuilderSettings).Return(builderSettings).Repeat.Any(); ;
}
public void PropertiesShouldBeGivenDefaultValues()
{
var builderSetup = new BuilderSettings();
var obj = Builder<MyClass>.CreateNew().Build();
Assert.That(obj.Int, Is.EqualTo(1));
Assert.That(obj.StringOne, Is.EqualTo("StringOne1"));
Assert.That(obj.StringTwo, Is.EqualTo("StringTwo1"));
Assert.That(obj.EnumProperty, Is.EqualTo(MyEnum.EnumValue1));
}
public void ShouldBeAbleToDisableAutomaticPropertyNamingForASpecificFieldOfASpecificType()
{
var builderSetup = new BuilderSettings();
builderSetup.DisablePropertyNamingFor<MyClass, int>(x => x.Int);
var obj = new Builder(builderSetup).CreateNew<MyClass>().Build();
Assert.That(obj.Int, Is.EqualTo(0));
Assert.That(obj.Long, Is.EqualTo(1));
}
public void ShouldBeAbleToCreateAListOfAClassThatHasANullCharConstant()
{
var builderSetup = new BuilderSettings();
var list = new Builder(builderSetup).CreateListOfSize< MyClassWithCharConst>(2).Build();
foreach (var item in list)
{
Assert.That(item.GetNullCharConst(), Is.EqualTo(MyClassWithCharConst.NullCharConst));
}
}
public void ShouldBeAbleToUseAndToSetPrivateProperties()
{
var builderSetup = new BuilderSettings();
using (mocks.Record())
{
operable.Expect(x => x.ObjectBuilder).Return(new ObjectBuilder<MyClass>(null, builderSetup));
objectBuilder.Expect(x => x.With(propertyExpression, 100));
}
OperableExtensions.And((IOperable<MyClass>)operable, propertyExpression, 100);
}
public void SetUp()
{
var builderSetup = new BuilderSettings();
mocks = new MockRepository();
reflectionUtil = mocks.DynamicMock<IReflectionUtil>();
builder = new ObjectBuilder<MyClass>(reflectionUtil, builderSetup);
myClassWithConstructorBuilder = new ObjectBuilder<MyClassWithConstructor>(reflectionUtil, builderSetup);
myClassWithOptionalConstructorBuilder = new ObjectBuilder<MyClassWithOptionalConstructor>(reflectionUtil, builderSetup);
}
public void Not_specifying_the_year()
{
// (Defaults to current year)
var builderSetup = new BuilderSettings();
var product = new Builder(builderSetup).CreateNew< Product>()
.With(x => x.Created = On.July.The21st.At(07, 00))
.Build();
Assert.That(product.Created, Is.EqualTo(new DateTime(DateTime.Now.Year, 07, 21, 07, 00, 00)));
}
public void ShouldBeAbleToUseAnd()
{
var builderSetup = new BuilderSettings();
using (mocks.Record())
{
operable.Expect(x => x.ObjectBuilder).Return(new ObjectBuilder<MyClass>(null, builderSetup));
objectBuilder.Expect(x => x.With(func));
}
OperableExtensions.And((IOperable<MyClass>)operable, func);
}
public void ShouldBeAbleToUseAndWithAnIndex()
{
var builderSetup = new BuilderSettings();
Action<MyClass, int> funcWithIndex = (x, idx) => x.StringOne = "String" + (idx + 5);
using (mocks.Record())
{
operable.Expect(x => x.ObjectBuilder).Return(new ObjectBuilder<MyClass>(null, builderSetup));
objectBuilder.Expect(x => x.With(funcWithIndex));
}
OperableExtensions.And((IOperable<MyClass>)operable, funcWithIndex);
}
public void should_be_able_to_use_IsConstructedUsing()
{
var builderSetup = new BuilderSettings();
var list =
new Builder(builderSetup)
.CreateListOfSize< MyClassWithConstructor>(1)
.TheFirst(1)
.WithConstructor(() => new MyClassWithConstructor(1, 2f))
.Build();
Assert.That(list.Count, Is.EqualTo(1));
}
public void should_be_able_to_create_a_list_using_legacy_syntax()
{
var builderSetup = new BuilderSettings();
var list =
new Builder(builderSetup)
.CreateListOfSize< MyClassWithConstructor>(10)
.All()
.WithConstructor(() => new MyClassWithConstructor(theString, theDecimal))
.Build();
Assert.That(list.Count, Is.EqualTo(10));
}
public void Fluent_dates_example()
{
var builderSetup = new BuilderSettings();
var product = new Builder(builderSetup)
.CreateNew< Product>()
.With(x => x.Created = The.Year(2006).On.May.The10th.At(09, 00))
.With(x => x.LastEdited = On.August.The15th.At(15, 43))
.Build();
Assert.That(product.Created, Is.EqualTo(new DateTime(2006, 5, 10, 09, 00, 00)));
Assert.That(product.LastEdited, Is.EqualTo(new DateTime(DateTime.Now.Year, 8, 15, 15, 43, 00)));
}
public void ShouldBeAbleToPickUsingExactlyConstraint()
{
var builderSetup = new BuilderSettings();
var simpleClasses =Builder<SimpleClass>.CreateListOfSize(10).Build();
var products = Builder<MyClass>
.CreateListOfSize(10)
.All()
.With(x => x.SimpleClasses = Pick<SimpleClass>.UniqueRandomList(With.Exactly(1).Elements).From(simpleClasses)).Build();
for (int i = 0; i < products.Count; i++)
Assert.That(products[i].SimpleClasses.Count, Is.EqualTo(1));
}
public void Static_month_names()
{
// You can use the month names on their own without On
// which one you use is just a matter of preference or one or the other
// might read better in different contexts.
var builderSetup = new BuilderSettings();
var product = new Builder(builderSetup).CreateNew< Product>()
.With(x => x.Created = December.The10th.At(09, 00))
.Build();
Assert.That(product.Created, Is.EqualTo(new DateTime(DateTime.Now.Year, 12, 10, 09, 00, 00)));
}
public void should_be_able_to_use_legacy_singular_syntax()
{
var builderSetup = new BuilderSettings();
var list =
new Builder(builderSetup)
.CreateListOfSize< MyClassWithConstructor>(1)
.TheFirst(1)
.WithConstructor(() => new MyClassWithConstructor(theString, theDecimal))
.Build();
Assert.That(list[0].String, Is.EqualTo(theString));
Assert.That(list[0].Decimal, Is.EqualTo(theDecimal));
}
public void should_set_properties_through_constructor_args_using_legacy_syntax()
{
var builderSetup = new BuilderSettings();
var list =
new Builder(builderSetup)
.CreateListOfSize< MyClassWithConstructor>(10)
.All()
.WithConstructor(() => new MyClassWithConstructor(theString, theDecimal))
.Build();
Assert.That(list[0].String, Is.EqualTo(theString));
Assert.That(list[0].Decimal, Is.EqualTo(theDecimal));
}
public void CanOnlyUseAndThePreviousAfterAnotherDeclaration()
{
var builderSetup = new BuilderSettings();
Assert.Throws<BuilderException>(() =>
{
new Builder(builderSetup)
.CreateListOfSize< MyClass>(10)
.ThePrevious(5)
.With(x => x.StringOne = "test")
.Build();
});
}
public void ShouldComplainIfRandomAmountTooBigForRange()
{
var builderSetup = new BuilderSettings();
Assert.Throws<ArgumentException>(() =>
{
new Builder(builderSetup)
.CreateListOfSize< MyClass>(10)
.Random(5, 0, 3)
.With(x => x.StringOne = "test")
.Build();
});
}
public void AutomaticPropertyAndPublicFieldNamingCanBeSwitchedOff()
{
var builderSetup = new BuilderSettings();
builderSetup.AutoNameProperties = false;
var products = new Builder(builderSetup).CreateListOfSize< Product>(10).Build();
Assert.That(products[0].Title, Is.Null);
Assert.That(products[9].Title, Is.Null);
Assert.That(products[0].Id, Is.EqualTo(0));
Assert.That(products[9].Id, Is.EqualTo(0));
}
public void WhenPickingFromSmallListLargeNumberOfTimesShouldPickEachItemAtLeastOnce()
{
var builderSetup = new BuilderSettings();
var fruits = new List<string>() { "apple", "orange", "banana", "pear" };
var fruitBaskets =
Builder<MyClass>
.CreateListOfSize(100)
.All()
.With(x => x.StringOne = Pick<string>.RandomItemFrom(fruits))
.Build();
var fruitsPicked = fruitBaskets.Select(x => x.StringOne).Distinct();
Assert.AreEqual(4, fruitsPicked.Count());
}
public void Issue68_ReadonlyProperty_ShouldNotWriteTraceDueToAttemptingToSetAPropertyThatCannotBeSet()
{
var builderSetup = new BuilderSettings();
var traceListener = Substitute.For<TraceListener>();
Trace.Listeners.Add(traceListener);
var product = new Builder(builderSetup)
.CreateListOfSize< DataModel>(2)
.All()
.With(x => x.ExpirationMonth = "01")
.With(x => x.ExpirationYear = "2010")
.Build();
traceListener.DidNotReceiveWithAnyArgs().WriteLine("");
Trace.Listeners.Remove(traceListener);
}
public void Building_single_objects_1()
{
BuilderSettings builderSettings = new BuilderSettings();
var product = new Builder(builderSettings).CreateNew <Product>().Build();
}
public RandomValuePropertyNamer(BuilderSettings builderSettings)
: this(new RandomGenerator(), new ReflectionUtil(), false, builderSettings)
{
}
void Start()
{
TheBuilderSettings = FindObjectOfType <BuilderSettings>();
}
public RandomValuePropertyNamer(IRandomGenerator generator, IReflectionUtil reflectionUtil, bool generatePositiveValuesOnly, DateTime minDate, DateTime maxDate, bool useLoremIpsumForStrings, BuilderSettings builderSettings)
: base(reflectionUtil, builderSettings)
{
this.generator = generator;
this.generatePositiveValuesOnly = generatePositiveValuesOnly;
this.useLoremIpsumForStrings = useLoremIpsumForStrings;
BuilderSettings = builderSettings;
this.minDate = minDate;
this.maxDate = maxDate;
}
public RandomValuePropertyNamer(IRandomGenerator generator, IReflectionUtil reflectionUtil, bool generatePositiveValuesOnly, BuilderSettings builderSettings)
: this(generator, reflectionUtil, generatePositiveValuesOnly, DateTime.MinValue, DateTime.MaxValue, false, builderSettings)
{
this.generator = generator;
}
public void Configuration_1(BuilderSettings builderSettings)
{
builderSettings.SetPersistenceService(new MyCustomPersistenceService());
}
public void Lists_1()
{
BuilderSettings builderSettings = new BuilderSettings();
var products = new Builder(builderSettings).CreateListOfSize <Product>(10).Build();
}
public void ShouldBeAbleToCreateUsingDefaultConstructor()
{
var builderSetup = new BuilderSettings();
new RandomValuePropertyNamer(builderSetup);
}
void Start()
{
TheBuilderSettings = FindObjectOfType <BuilderSettings>();
TheBuilderSettings.GetComponent <BuilderSelector>().BuildCamera = GetComponent <Camera>();
}
protected PropertyNamer(IReflectionUtil reflectionUtil, BuilderSettings builderSettings)
{
this.ReflectionUtil = reflectionUtil;
BuilderSettings = builderSettings;
}
/// <summary>
/// Give the node an opportunity to determine its own result type.
/// </summary>
public virtual void OnDetermineResultType(BuilderSettings settings)
{
}
/// <summary>
/// Allow the node to perform any compile-time validation.
/// </summary>
/// <param name="settings">Settings for performing validation.</param>
/// <param name="exceptionNode">Raise exceptions on this node.</param>
public virtual void OnStaticValidation(BuilderSettings settings, ParseTreeNode exceptionNode)
{
}
public void Configuration_3(BuilderSettings builderSettings)
{
builderSettings.SetPropertyNamerFor <Product>(new CustomProductPropertyNamer(new ReflectionUtil(), builderSettings));
}
public void Configuration_4(BuilderSettings builderSettings)
{
builderSettings.DisablePropertyNamingFor <Product, int>(x => x.Id);
}
void Start()
{
TheBuilderSettings = FindObjectOfType <BuilderSettings>();
TheImage = GetComponent <Image>();
}
public RandomValueNamerShortStrings(BuilderSettings settings)
: base(settings)
{
_generator = new RandomGenerator();
}
public void BeforeEach()
{
this.builderSettings = new EntityFrameworkBuilderSetup().SetUp();
}
public Layout(BuilderSettings settings)
{
_template = ReadTemplate(settings.RootPath);
_baseUrl = settings.BaseUrl;
}
