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())
{
}
