public void Test_Construct_WithNotHasClassDef_ShouldRaiseError() { //This is a PropDescriptor that wraps a //UIGridColumn that wraps a PropDef and if the //PropDef is null this should therefore raise and error. //---------------Set up test pack------------------- IUIGridColumn gridColumn = MockRepository.GenerateStub <IUIGridColumn>(); gridColumn.PropertyName = RandomValueGen.GetRandomString(); //---------------Assert Precondition---------------- //Assert.IsFalse(gridColumn.HasPropDef); //---------------Execute Test ---------------------- try { new PropertyDescriptorReflectiveProp(gridColumn); Assert.Fail("expected ArgumentNullException"); } //---------------Test Result ----------------------- catch (HabaneroArgumentException ex) { Assert.AreEqual("gridColumn.ClassDef", ex.ParameterName); } }
public void WithCustomMessage() { // Arrange var expected = RandomValueGen.GetRandomString(); var test = RandomValueGen.GetRandomString(); var nonMatch = RandomValueGen.GetAnother(test); // Pre-Assert // Act Assert.That(() => { Expect(test).To.Equal(nonMatch, expected); }, Throws.Exception.InstanceOf <UnmetExpectationException>() .With.Message.Contains(expected)); Assert.That(() => { Expect(test).To.Equal(nonMatch, () => expected); }, Throws.Exception.InstanceOf <UnmetExpectationException>() .With.Message.Contains(expected)); // Assert }
public void Test_SetValue_WhenPropInfoNull_ShouldDoNothing() { //---------------Set up test pack------------------- IClassDef classDef = MockRepository.GenerateStub <IClassDef>(); classDef.ClassType = typeof(FakeBO); var gridColumn = GetGridColumnStub(classDef); gridColumn.PropertyName = "-FakeBOName-"; PropertyDescriptorReflectiveProp propDescriptor = new PropertyDescriptorReflectivePropSpy(gridColumn, null); FakeBO fakeBO = new FakeBO { FakeBOName = RandomValueGen.GetRandomString() }; //---------------Assert Precondition---------------- Assert.AreSame(classDef, gridColumn.ClassDef); Assert.AreSame(typeof(FakeBO), gridColumn.ClassDef.ClassType); Assert.IsNotNullOrEmpty(fakeBO.FakeBOName); //---------------Execute Test ---------------------- propDescriptor.SetValue(fakeBO, RandomValueGen.GetRandomString()); //---------------Test Result ----------------------- Assert.IsTrue(true, "If got here all is good"); }
public void ToBeTrue_WhenValueIsFalse_GivenCustomMessage_ShouldThrow() { // Arrange var value = false; var message = RandomValueGen.GetRandomString(12); // Pre-Assert // Act Assert.That( () => Expectations.Expect(value).To.Be.True(message), Throws.Exception.InstanceOf <AssertionException>() .With.Message.Contains($"Expected True but got {value}") ); Assert.That( () => Expectations.Expect(value).To.Be.True(message), Throws.Exception.InstanceOf <AssertionException>() .With.Message.Contains(message) ); // Assert }
public void Test_GetPropertyValue_ShouldSetBOPropsValue() { //---------------Set up test pack------------------- ContactPersonTestBO contactPersonTestBO = new ContactPersonTestBO(); const string propName = "Surname"; BOPropertyMapper boPropertyMapper = new BOPropertyMapper(propName) { BusinessObject = contactPersonTestBO }; var expectedPropValue = RandomValueGen.GetRandomString(); boPropertyMapper.Property.Value = expectedPropValue; //---------------Assert Precondition---------------- Assert.IsNotNull(boPropertyMapper.Property); Assert.AreEqual(expectedPropValue, boPropertyMapper.Property.Value); //---------------Execute Test ---------------------- object actualValue = boPropertyMapper.GetPropertyValue(); //---------------Test Result ----------------------- Assert.AreEqual(expectedPropValue, actualValue); Assert.AreEqual(expectedPropValue, contactPersonTestBO.Surname); }
public void Test_SetPropertyValue_WhenBONull_ShouldRaiseError() { //---------------Set up test pack------------------- const string propName = "Surname"; BOPropertyMapper boPropertyMapper = new BOPropertyMapper(propName); //---------------Assert Precondition---------------- Assert.IsNull(boPropertyMapper.BusinessObject); //---------------Execute Test ---------------------- try { boPropertyMapper.SetPropertyValue(RandomValueGen.GetRandomString()); Assert.Fail("Expected to throw an HabaneroApplicationException"); } //---------------Test Result ----------------------- catch (HabaneroApplicationException ex) { string expectedErrorMessage = string.Format( "Tried to Set Property Value the BOPropertyMapper for Property '{0}' when the BusinessObject is not set " , propName); StringAssert.Contains(expectedErrorMessage, ex.Message); } }
public void GetEnumerator_ShouldEnumerateOverDistinctKeyValuePairsWithPriority() { // Arrange var key1 = RandomValueGen.GetRandomString(); var key2 = RandomValueGen.GetAnother(key1); var key3 = RandomValueGen.GetAnother <string>(new[] { key1, key2 }); var expected1 = RandomValueGen.GetRandomString(); var expected2 = RandomValueGen.GetAnother(expected1); var expected3 = RandomValueGen.GetAnother <string>(new[] { expected1, expected2 }); var unexpected = RandomValueGen.GetAnother <string>(new[] { expected1, expected2, expected3 }); var sut = Create( new Dictionary <string, string>() { [key1] = expected1, [key2] = expected2 }, new Dictionary <string, string>() { [key1] = unexpected, [key3] = expected3 }); var collector = new List <KeyValuePair <string, string> >(); // Pre-assert // Act foreach (var kvp in sut) { collector.Add(kvp); } // Assert Expectations.Expect(collector.Count).To.Equal(3); Expectations.Expect(collector.Any(kvp => kvp.Key == key1 && kvp.Value == expected1)).To.Be.True(); Expectations.Expect(collector.Any(kvp => kvp.Key == key2 && kvp.Value == expected2)).To.Be.True(); Expectations.Expect(collector.Any(kvp => kvp.Key == key3 && kvp.Value == expected3)).To.Be.True(); }
public void TestAcceptance_LockNumberGenerator() { //---------------Set up test pack------------------- //Create an instance of the number for a specific type of number (e.g. Invoice number) BORegistry.BusinessObjectManager = new BusinessObjectManagerSpy(); string numberType = RandomValueGen.GetRandomString(); BOSequenceNumberLocking.LoadNumberGenClassDef(); //DatabaseConnection.CurrentConnection.ExecuteRawSql("Delete From numbergenerator"); INumberGenerator numGen = new NumberGeneratorPessimisticLocking(numberType); numGen.SetSequenceNumber(0); Thread.Sleep(1); // ensure that the new time is higher. just here to check if this resolves a sporadically failing test. //get the next number for invoice number numGen.NextNumber(); //Clear all loaded objects from object manager BORegistry.BusinessObjectManager = new BusinessObjectManagerSpy(); Thread.Sleep(1); // ensure that the new time is higher. just here to check if this resolves a sporadically failing test. //---------------Execute Test ---------------------- //Create a seperate instance of the number generator (simulating a simultaneous user). INumberGenerator numGen2 = new NumberGeneratorPessimisticLocking(numberType); Assert.AreNotSame(numGen, numGen2); //try Get second number try { numGen2.NextNumber(); Assert.Fail("Should not be able to get second number since locked"); } //---------------Test Result ----------------------- //should get locking error catch (BusObjPessimisticConcurrencyControlException ex) { Assert.IsTrue(ex.Message.Contains("You cannot begin edits on the 'BOSequenceNumberLocking', as another user has started edits and therefore locked to this record")); } }
public void IncrementVersionsUnder_ShouldPersistAfterDoingIncrements_ForEachOtherNuspecUtil() { //---------------Set up test pack------------------- var path1 = RandomValueGen.GetRandomFileName(); var path2 = RandomValueGen.GetRandomFileName(); var util1 = CreateRandomNuspecUtil(); var util2 = CreateRandomNuspecUtil(util1.PackageId); var factory = Substitute.For <INuspecUtilFactory>(); factory.LoadNuspecAt(path1).Returns(util1); factory.LoadNuspecAt(path2).Returns(util2); var finder = Substitute.For <INuspecFinder>(); finder.NuspecPaths.Returns(new[] { path1, path2 }); var sut = Create(finder, factory); //---------------Assert Precondition---------------- Assert.AreNotEqual(util1.PackageId, util2.PackageId); //---------------Execute Test ---------------------- sut.IncrementVersionsUnder(RandomValueGen.GetRandomString()); //---------------Test Result ----------------------- Received.InOrder(() => { util1.EnsureSameDependencyGroupForAllTargetFrameworks(); util1.IncrementVersion(); util2.EnsureSameDependencyGroupForAllTargetFrameworks(); util2.IncrementVersion(); util1.SetPackageDependencyVersionIfExists(util2.PackageId, util2.Version); util2.SetPackageDependencyVersionIfExists(util1.PackageId, util1.Version); util1.Persist(); util2.Persist(); }); }
// ReSharper disable InconsistentNaming public void Test_SetDisplayPropertyValue_ShouldSetPropValue() { //---------------Set up test pack------------------- const string propName = "TestProp"; ClassDef.ClassDefs.Clear(); var myBOClassDef = MyBO.LoadClassDefWithRelationship(); MyRelatedBo.LoadClassDef(); var myBO = (MyBO)myBOClassDef.CreateNewBusinessObject(); var boMapper = new BOMapper(myBO); var initialPropValue = RandomValueGen.GetRandomString(); myBO.SetPropertyValue(propName, initialPropValue); //---------------Assert Precondition---------------- Assert.AreEqual(initialPropValue, myBO.GetPropertyValue(propName)); //---------------Execute Test ---------------------- var expectedPropValue = RandomValueGen.GetRandomString(); boMapper.SetDisplayPropertyValue(propName, expectedPropValue); //---------------Test Result ----------------------- Assert.AreEqual(expectedPropValue, myBO.GetPropertyValue(propName)); }
public void Given_InvalidArgument_ShouldPrintHelp( char shortName, string longName, string helpText) { //---------------Set up test pack------------------- var heading = RandomValueGen.GetRandomString(); var copyRight = RandomValueGen.GetRandomString(); var args = new[] { "-a" }; var result = new List <string>(); //---------------Assert Precondition---------------- //---------------Execute Test ---------------------- var sut = Create(args, heading, copyRight, s => result.Add(s)); //---------------Test Result ----------------------- Assert.AreEqual(CommandlineOptions.ExitCodes.ShowedHelp, sut.ExitCode); var finalResult = string.Join("\n", result); var lines = finalResult.Split(new[] { "\n", "\r" }, StringSplitOptions.RemoveEmptyEntries); var re = new Regex("-" + shortName + ",\\s.*--" + longName + "\\s.*" + helpText); Expect(lines) .To.Contain.Exactly(1) .Matched.By(s => re.IsMatch(s), () => $@"no match for help line containing ""-{ shortName }"", ""--{ longName }"" and ""{ helpText }""\n\nFull text was:{ finalResult }" ); }
public void AddAttachment_ReturnsIDForAttachment() { //---------------Set up test pack------------------- using (var email = CreateWithRandomRecipientAndSender()) { var fileName = RandomValueGen.GetRandomString(); var data = RandomValueGen.GetRandomBytes(); var mimeType = "text/plain"; email.Subject = RandomValueGen.GetRandomString(); email.Body = RandomValueGen.GetRandomString(); //---------------Assert Precondition---------------- //---------------Execute Test ---------------------- var id = email.AddAttachment(fileName, data, mimeType, true); var message = email.CreateMessage(); //---------------Test Result ----------------------- var att = message.Attachments.FirstOrDefault(); Assert.IsNotNull(att); Assert.AreEqual(id, att.ContentId); Assert.IsTrue(att.ContentDisposition.Inline); Assert.AreEqual(att.ContentDisposition.DispositionType, DispositionTypeNames.Inline); } }
public void AddAttachment_AddsAttachmentToAttachmentsList() { //---------------Set up test pack------------------- using (var email = CreateWithRandomRecipientAndSender()) { var fileName = RandomValueGen.GetRandomString(); var data = RandomValueGen.GetRandomBytes(); var mimeType = RandomValueGen.GetRandomMIMEType(); //---------------Assert Precondition---------------- Assert.AreEqual(0, email.Attachments.Count); //---------------Execute Test ---------------------- email.AddAttachment(fileName, data, mimeType); //---------------Test Result ----------------------- var attachment = email.Attachments.FirstOrDefault(a => a.Name == fileName && a.MIMEType == mimeType); Assert.IsNotNull(attachment); CollectionAssert.AreEqual(data, attachment.Data); var message = email.CreateMessage(); var actual = message.Attachments.First(); Assert.IsFalse(actual.ContentDisposition.Inline); Assert.AreEqual(actual.ContentDisposition.DispositionType, DispositionTypeNames.Attachment); } }
public void Test_GetValue_ShouldGetValueFromBO() { //---------------Set up test pack------------------- IClassDef classDef = MockRepository.GenerateStub <IClassDef>(); classDef.ClassType = typeof(FakeBO); var gridColumn = GetGridColumnStub(classDef); gridColumn.PropertyName = "FakeBOName"; PropertyDescriptorPropDef propDescriptor = new PropertyDescriptorPropDef(gridColumn); FakeBO fakeBO = new FakeBO { FakeBOName = RandomValueGen.GetRandomString() }; //---------------Assert Precondition---------------- Assert.AreSame(classDef, gridColumn.ClassDef); Assert.AreSame(typeof(FakeBO), gridColumn.ClassDef.ClassType); Assert.IsNotNullOrEmpty(fakeBO.FakeBOName); //---------------Execute Test ---------------------- var actualValue = propDescriptor.GetValue(fakeBO); //---------------Test Result ----------------------- Assert.AreEqual(fakeBO.FakeBOName, actualValue); }
public void Test_GetValue_WhenPropInfoNull_ShouldReturnNull() { //---------------Set up test pack------------------- IClassDef classDef = MockRepository.GenerateStub <IClassDef>(); classDef.ClassType = typeof(FakeBO); var gridColumn = GetGridColumnStub(classDef); gridColumn.PropertyName = "FakeBOName"; var propDescriptor = new PropertyDescriptorReflectivePropSpy(gridColumn, null); FakeBO fakeBO = new FakeBO { FakeBOName = RandomValueGen.GetRandomString() }; //---------------Assert Precondition---------------- Assert.AreSame(classDef, gridColumn.ClassDef); Assert.AreSame(typeof(FakeBO), gridColumn.ClassDef.ClassType); Assert.IsNotNullOrEmpty(fakeBO.FakeBOName); //---------------Execute Test ---------------------- var actualValue = propDescriptor.GetValue(fakeBO); //---------------Test Result ----------------------- Assert.IsNull(actualValue); }
public void Test_SetValue_ShouldRaiseError() { //---------------Set up test pack------------------- PropertyDescriptorID propDescriptor = new PropertyDescriptorID(); FakeBO fakeBO = new FakeBO { FakeBOName = RandomValueGen.GetRandomString() }; //---------------Assert Precondition---------------- Assert.IsNotNullOrEmpty(fakeBO.FakeBOName); //---------------Execute Test ---------------------- var expectedValue = RandomValueGen.GetRandomString(); try { propDescriptor.SetValue(fakeBO, expectedValue); Assert.Fail("Expected to throw an HabaneroDeveloperException"); } //---------------Test Result ----------------------- catch (HabaneroDeveloperException ex) { StringAssert.Contains("The PropertyDescriptorID cannot set value since the objectID is ReadOnly", ex.Message); } }
public void Keys_ShouldReturnAllDistinctKeys() { // Arrange var k1 = RandomValueGen.GetRandomString(); var k2 = RandomValueGen.GetAnother(k1); var sut = Create(new Dictionary <string, string>() { [k1] = RandomValueGen.GetRandomString(), [k2] = RandomValueGen.GetRandomString() }, new Dictionary <string, string>() { [k1] = RandomValueGen.GetRandomString() }); // Pre-assert // Act var result = sut.Keys; // Assert Expectations.Expect(result.Count).To.Equal(2); Expectations.Expect(result).To.Contain.Exactly(1).Equal.To(k1); Expectations.Expect(result).To.Contain.Exactly(1).Equal.To(k2); }
public void GivenTwoDictionarisWhicCollide_ShouldReturnValueFromFirst() { // Arrange var key = RandomValueGen.GetRandomString(); var value1 = RandomValueGen.GetRandomString(); var value2 = RandomValueGen.GetAnother(value1); var dict1 = new Dictionary <string, string>() { [key] = value1 }; var dict2 = new Dictionary <string, string>() { [key] = value2 }; var sut = Create(dict1, dict2); // Pre-assert // Act var result = sut[key]; // Assert Expectations.Expect(result).To.Equal(value1); }
public CarViewModelBuilder() { // _car = BuildValid(); _car.Make = RandomValueGen.GetRandomString(); _car.Model = RandomValueGen.GetRandomString(); }
public void Contains_WhenOneDictionaryAndItContainsAMatchingPair_ShouldReturnTrue() { // Arrange var kvp = new KeyValuePair <string, string>(RandomValueGen.GetRandomString(), RandomValueGen.GetRandomString()); var inner = new Dictionary <string, string>() { [kvp.Key] = kvp.Value }; var sut = Create(inner); // Pre-assert // Act var result = sut.Contains(kvp); // Assert Expectations.Expect(result).To.Be.True(); }
public void Contains_WhenTwoDictionariesAndNeitherContainAMatchingPair_ShouldReturnFalse() { // Arrange var kvp = new KeyValuePair <string, string>(RandomValueGen.GetRandomString(), RandomValueGen.GetRandomString()); var inner1 = new Dictionary <string, string>(); var inner2 = new Dictionary <string, string>(); var sut = Create(inner1, inner2); // Pre-assert // Act var result = sut.Contains(kvp); // Assert Expectations.Expect(result).To.Be.False(); }
private static PropRuleInteger CreatePropRuleInt(int min, int max) { return(new PropRuleInteger(RandomValueGen.GetRandomString(), RandomValueGen.GetRandomString(), min, max)); }
public void Add_GivenKeyValuePair_ShouldThrow_InvalidOperationException() { // Arrange var sut = Create(new Dictionary <string, string>()); // Pre-assert // Act Expectations.Expect( () => sut.Add(new KeyValuePair <string, string>(RandomValueGen.GetRandomString(), RandomValueGen.GetRandomString())) ).To.Throw <InvalidOperationException>() .With.Message.Containing("read-only"); // Assert }
public PropDefFake() : base(RandomValueGen.GetRandomString(), typeof(int), PropReadWriteRule.ReadWrite, null) { }
public void SetExistingPackageDependencyVersion_WhenDependencyNotFound_ShouldNotChangeDocument() { //---------------Set up test pack------------------- var sut = Create(); var before = sut.NuspecXml; //---------------Assert Precondition---------------- //---------------Execute Test ---------------------- sut.SetExistingPackageDependencyVersion(RandomValueGen.GetRandomString(10, 20), RandomValueGen.GetRandomString()); //---------------Test Result ----------------------- Assert.AreEqual(before, sut.NuspecXml); }
private ScriptBundleFacade Create(string name = null) { return(new ScriptBundleFacade(name ?? "~/" + RandomValueGen.GetRandomString())); }
public FakePropertyInfo() { _declaringType = MockRepository.GenerateMock <Type>(); _propType = MockRepository.GenerateMock <Type>(); _propName = RandomValueGen.GetRandomString(); }
public ReflectionPropertyMapperStub() : base(RandomValueGen.GetRandomString()) { }
private static string GetRandomString() { return(RandomValueGen.GetRandomString()); }
public SingleRelDefFake() : this(RandomValueGen.GetRandomString()) { }