public void Construct_GivenTwoStringsAndBinaryData_ShouldUseStringsForFolderAndFileName()
{
//---------------Set up test pack-------------------
var baseFolder = GetExecutingAssemblyFolder();
var fileName = RandomValueGen.GetRandomString(5, 10) + "." + RandomValueGen.GetRandomString(3, 3);
var data = RandomValueGen.GetRandomBytes();
var expectedPath = Path.Combine(baseFolder, fileName);
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
using (new AutoTempFile(baseFolder, fileName, data))
{
//---------------Test Result -----------------------
Assert.IsTrue(File.Exists(expectedPath));
CollectionAssert.AreEqual(data, File.ReadAllBytes(expectedPath));
}
}
public void MakeTypeImplementing_GivenObjectToWrap_ShouldPassPropertyGetThrough()
{
//--------------- Arrange -------------------
var sut = Create();
var toWrap = new Sample1();
var expected = RandomValueGen.GetRandomString(2, 5);
//--------------- Assume ----------------
//--------------- Act ----------------------
var result = sut.MakeTypeImplementing <ISample1>();
var instance = (ISample1)CreateInstanceOf(result, new object[] { new[] { toWrap } });
instance.SetPropertyValue("Name", expected);
//--------------- Assert -----------------------
Expect(toWrap.Name).To.Equal(expected);
}
public void Test_GetRandomString_WhenMaxLengthGTGuidLength_ShouldReturnGuid()
{
//---------------Set up test pack-------------------
const int maxLength = 55;
int lengthOfGuidString = GetRandomString().Length;
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var randomString = RandomValueGen.GetRandomString(maxLength);
//---------------Test Result -----------------------
StringAssert.DoesNotContain("-", randomString);
StringAssert.DoesNotContain("{", randomString);
StringAssert.StartsWith("A", randomString);
Assert.AreEqual(lengthOfGuidString, randomString.Length);
Assert.AreNotEqual(maxLength, randomString.Length);
}
public void AddPDFAttachment_AddsAttachmentWithMIMEType_APPLICATION_SLASH_PDF()
{
//---------------Set up test pack-------------------
var fileName = RandomValueGen.GetRandomString();
var bytes = RandomValueGen.GetRandomBytes();
using (var email = CreateWithRandomRecipientAndSender())
{
//---------------Assert Precondition----------------
Assert.IsFalse(email.Attachments.Any());
//---------------Execute Test ----------------------
email.AddPDFAttachment(fileName, bytes);
//---------------Test Result -----------------------
Assert.AreEqual(1, email.Attachments.Count);
Assert.IsTrue(email.Attachments.All(a => a.Name == fileName && a.MIMEType == "application/pdf"));
}
}
public void CreateMessage_AddsAllAttachmentsToMailMessage()
{
//---------------Set up test pack-------------------
var fileName = RandomValueGen.GetRandomString();
var data = RandomValueGen.GetRandomBytes();
var mimeType = "text/plain";
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
using (var email = CreateActualWithRandomRecipientAndSender())
{
email.AddAttachment(fileName, data, mimeType);
var message = email.CreateMessage();
//---------------Test Result -----------------------
Assert.AreEqual(1, message.Attachments.Count);
}
}
public void GetPropertyValue_WhenPropertyDataExistsAndMisMatchesTypeAndCantConvert_ShouldReturnDefault()
{
//--------------- Arrange -------------------
var expected = default(int);
var data = new Dictionary <string, object>()
{
{ "Id", RandomValueGen.GetRandomAlphaString() }
};
var sut = Create(data, typeof(IHaveId));
//--------------- Assume ----------------
//--------------- Act ----------------------
var result = sut.GetPropertyValue("Id");
//--------------- Assert -----------------------
Expect(result).To.Equal(expected);
}
public void TestSetGapSize_ShouldSetHorizontalGapSizeAndVerticalGapSize()
{
//---------------Set up test pack-------------------
ColumnLayoutManager columnLayoutManager = GetColumnLayoutManager();
var randomGapSize = RandomValueGen.GetRandomInt(1, 500);
//---------------Assert Precondition----------------
Assert.AreEqual(0, columnLayoutManager.GapSize);
Assert.AreEqual(LayoutManager.DefaultGapSize, columnLayoutManager.HorizontalGapSize);
Assert.AreEqual(LayoutManager.DefaultGapSize, columnLayoutManager.VerticalGapSize);
//---------------Execute Test ----------------------
columnLayoutManager.GapSize = randomGapSize;
//---------------Test Result -----------------------
Assert.AreEqual(randomGapSize, columnLayoutManager.GapSize);
Assert.AreEqual(randomGapSize, columnLayoutManager.HorizontalGapSize);
Assert.AreEqual(randomGapSize, columnLayoutManager.VerticalGapSize);
}
public void Test_CanResetValue_When_ShouldReturnTrue()
{
//---------------Set up test pack-------------------
var gridColumn = GetGridColumnStub();
gridColumn.PropertyName = "FakeBOName";
var propDescriptor = new PropertyDescriptorPropDef(gridColumn);
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
FakeBO fakeBO = new FakeBO();
fakeBO.FakeBOName = RandomValueGen.GetRandomString();
var canResetValue = propDescriptor.CanResetValue(fakeBO);
//---------------Test Result -----------------------
Assert.IsFalse(canResetValue);
}
public void DisplayErrorMessage_GivenAnotherMessage_ShouldNotEmitSecondDisplayFeedbackEvent()
{
//---------------Set up test pack-------------------
var eventAggregator = Substitute.For <IEventAggregator>();
var playerNotifier = CreatePlayerNotifier(eventAggregator: eventAggregator);
var firstMessage = RandomValueGen.GetRandomString();
var secondMessage = firstMessage + RandomValueGen.GetRandomString(2);
Func <string, string> expectedErrorMessageFor = s => "Error :: " + s;
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
playerNotifier.DisplayErrorMessage(firstMessage);
playerNotifier.DisplayErrorMessage(secondMessage);
//---------------Test Result -----------------------
eventAggregator.ShouldHavePublished <DisplayFeedbackEvent>(m => m.Message == expectedErrorMessageFor(firstMessage));
eventAggregator.ShouldNotHavePublished <DisplayFeedbackEvent>(m => m.Message == expectedErrorMessageFor(secondMessage));
}
public void Test_Width_ShouldReturnWidthFromColumn()
{
//---------------Set up test pack-------------------
IUIGridColumn gridColumn = GetGridColumnStub();
var expectedWidth = RandomValueGen.GetRandomInt(0, 33);
gridColumn.Width = expectedWidth;
PropertyDescriptorPropDef propDescriptor = new PropertyDescriptorPropDef(gridColumn);
//---------------Assert Precondition----------------
Assert.AreEqual(expectedWidth, gridColumn.Width);
//---------------Execute Test ----------------------
var width = propDescriptor.Width;
//---------------Test Result -----------------------
Assert.AreEqual(expectedWidth, width);
}
public void Test_Alignment_ShouldReturnAlignmentFromColumn()
{
//---------------Set up test pack-------------------
IUIGridColumn gridColumn = GetGridColumnStub();
var expectedAlignment = RandomValueGen.GetRandomEnum <PropAlignment>();;
gridColumn.Alignment = expectedAlignment;
PropertyDescriptorPropDef propDescriptor = new PropertyDescriptorPropDef(gridColumn);
//---------------Assert Precondition----------------
Assert.AreEqual(expectedAlignment, gridColumn.Alignment);
//---------------Execute Test ----------------------
var alignment = propDescriptor.Alignment;
//---------------Test Result -----------------------
Assert.AreEqual(expectedAlignment, alignment);
}
public void Transform_ShouldTransform()
{
//---------------Set up test pack-------------------
var source = new
{
FirstName = RandomValueGen.GetRandomString(),
LastName = RandomValueGen.GetRandomString()
};
var expected = source.FirstName + " " + source.LastName;
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var result = source.Transform(o => new { FullName = o.FirstName + " " + o.LastName });
//---------------Test Result -----------------------
Assert.AreEqual(expected, result.FullName);
}
public void ShouldReturnSingleTextNodeOfElement()
{
// test setup
var text = RandomValueGen.GetRandomString(10, 20);
var tag = RandomValueGen.GetRandomAlphaString(10, 20);
var el = new XElement(tag, new XText(text));
// pre-conditions
// execute test
var result = el.Text();
// test result
Expect(result)
.Not.To.Be.Null();
Expect(result)
.To.Equal(text);
}
public void Test_Name_WhenHasHabaneroReflectionIndicators_ShouldBeGridColumnPropertyName()
{
//---------------Set up test pack-------------------
IUIGridColumn gridColumn = GetGridColumnStub();
string expectedName = "-" + RandomValueGen.GetRandomString() + "-";
gridColumn.PropertyName = expectedName;
PropertyDescriptor propDescriptor = new PropertyDescriptorReflectivePropSpy(gridColumn);
//---------------Assert Precondition----------------
Assert.AreEqual(expectedName, gridColumn.PropertyName);
//---------------Execute Test ----------------------
var actualPropDescriptorName = propDescriptor.Name;
//propDescriptor.DisplayName
//---------------Test Result -----------------------
Assert.AreEqual(expectedName, actualPropDescriptorName);
}
public void CallThrough_WhenConstructedWith_FuzzyFalse_AndMethodNameCaseMismatch_ShouldThrow()
{
//--------------- Arrange -------------------
var toWrap = new Cow();
var pitch = RandomValueGen.GetRandomString();
var count = RandomValueGen.GetRandomInt();
var sut = Create(toWrap, false);
//--------------- Assume ----------------
//--------------- Act ----------------------
Expect(() =>
sut.CallThrough("mOo", new object[] { count, pitch })
)
.To.Throw <MethodNotFoundException>();
//--------------- Assert -----------------------
}
public void SplitPartsOutOf_GivenStringWithA_GO_ShouldReturnTheParts()
{
//---------------Set up test pack-------------------
var sut = Create();
var first = RandomValueGen.GetRandomString();
var second = RandomValueGen.GetRandomString();
var input = first + "\r\nGO\r\n" + second;
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var result = sut.SplitPartsOutOf(input);
//---------------Test Result -----------------------
Assert.IsNotNull(result);
Assert.AreEqual(2, result.Length);
Assert.AreEqual(first, result[0]);
Assert.AreEqual(second, result[1]);
}
public void GetPropertyValue_WhenPropertyDataExistsAndMatchesTypeAndDictionaryIsInsensitive_ShouldReturnValue()
{
//--------------- Arrange -------------------
var expected = RandomValueGen.GetRandomInt();
var data = new Dictionary <string, object>(StringComparer.OrdinalIgnoreCase)
{
{ "id", expected }
};
var sut = Create(data, typeof(IHaveId));
//--------------- Assume ----------------
//--------------- Act ----------------------
var result = sut.GetPropertyValue("iD");
//--------------- Assert -----------------------
Expect(result).To.Equal(expected);
}
public void CreateNotStartedFor_GivenAction_ShouldReturnUnstartedTaskWhichCanBeStartedAtTheWhimsyOfOne()
{
//---------------Set up test pack-------------------
var sut = Create();
var expected = RandomValueGen.GetRandomInt(10, 100);
var result = 0;
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var task = sut.CreateNotStartedFor(() => { result = expected; });
//---------------Test Result -----------------------
Assert.IsInstanceOf <Task>(task);
task.Start();
task.Wait();
Assert.AreEqual(expected, result);
}
public void StringData_set_ShouldPutStringIntoFile()
{
//---------------Set up test pack-------------------
var unexpected = RandomValueGen.GetRandomString();
var expected = RandomValueGen.GetRandomString();
using (var sut = new AutoTempFile(unexpected))
{
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
sut.StringData = expected;
var result = File.ReadAllBytes(sut.Path);
//---------------Test Result -----------------------
Assert.AreEqual(expected, result);
}
}
public void GetPropertyValue_WhenPropertyDataExistsAndMatchesType_ShouldReturnValue()
{
//--------------- Arrange -------------------
var expected = RandomValueGen.GetRandomInt();
var data = new Dictionary <string, object>()
{
{ "Id", expected }
};
var sut = Create(data, typeof(IHaveId));
//--------------- Assume ----------------
//--------------- Act ----------------------
var result = sut.GetPropertyValue("Id");
//--------------- Assert -----------------------
Expect(result).To.Equal(expected);
}
public void Spool_WhenOneEmailNotSent_WhenEmailFailsToSend_BacksOffIncrementallyWithMultiplier()
{
// test setup
var email = CreateSubstituteEmail();
var func = EmailGeneratorWith(email);
var errorMessage = RandomValueGen.GetRandomString();
email.When(e => e.Send()).Do(ci => { throw new Exception(errorMessage); });
var dto = EmailBuilder.Create().WithRandomProps().WithRandomRecipient().WithRandomAttachment(2).Build();
dto.EmailRecipients.First().IsBCC = true;
dto.EmailRecipients.First().IsCC = true;
dto.SendAttempts = 1;
var ctx = SubstituteEmailContextBuilder.Create().WithEmails(dto).Build();
var deps = FakeEmailSpoolerDependenciesBuilder.Create()
.WithDbContext(ctx)
.WithEmailGenerator(func)
.Build();
var backoff = RandomValueGen.GetRandomInt(2, 10);
deps.EmailSpoolerConfig.BackoffIntervalInMinutes.ReturnsForAnyArgs(ci => backoff);
// pre-conditions
Assert.AreEqual(2, dto.EmailAttachments.Count(a => a.Data.Length > 0 && a.Name.Length > 0));
// execute test
ctx.DidNotReceive().SaveChanges();
var beforeRun = DateTime.Now;
Assert.DoesNotThrow(() =>
{
using (var spooler = new EmailSpooler(deps))
{
spooler.Spool();
}
});
// test result
Assert.IsFalse(dto.Sent);
Assert.AreEqual(errorMessage, dto.LastError);
Assert.AreEqual(2, dto.SendAttempts);
Assert.That(beforeRun.AddMinutes(backoff * 4), Is.LessThanOrEqualTo(dto.SendAt));
Assert.That(beforeRun.AddMinutes(backoff * 4).AddSeconds(5), Is.GreaterThanOrEqualTo(dto.SendAt));
ctx.Received().SaveChanges();
}
public void Construct_Given_Type_And_TypeLoaderException_ShouldSetProperties()
{
//---------------Set up test pack-------------------
var type = GetType();
var innerException = new TypeLoadException($"Access denied: {RandomValueGen.GetRandomString()}");
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var sut = new UnableToCreateDynamicBuilderException(type, innerException);
//---------------Test Result -----------------------
var typeName = type.PrettyName();
Expect(sut.Message)
.To.Start.With($"Unable to create dynamic builder for type {typeName}. If {typeName} is internal, you should make InternalsVisibleTo \"PeanutButter.RandomGenerators.GeneratedBuilders\"");
Expect(sut.Type).To.Equal(type);
Expect(sut.InnerException).To.Equal(innerException);
}
public void Contains_WhenTwoDictionariesAndSecondContainsAMatchingPair_ShouldReturnTrue()
{
// Arrange
var kvp = new KeyValuePair <string, string>(RandomValueGen.GetRandomString(), RandomValueGen.GetRandomString());
var inner1 = new Dictionary <string, string>();
var inner2 = new Dictionary <string, string>
{
[kvp.Key] = kvp.Value
};
var sut = Create(inner1, inner2);
// Pre-assert
// Act
var result = sut.Contains(kvp);
// Assert
Expectations.Expect(result).To.Be.True();
}
public void Construct_ShouldBeAbleToCreateDbByName()
{
//---------------Set up test pack-------------------
var dbName = RandomValueGen.GetRandomAlphaString(5, 10);
using (var db = new TempDBLocalDb(dbName, null))
{
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
//---------------Test Result -----------------------
Assert.IsTrue(File.Exists(db.DatabasePath));
using (var conn = new SqlConnection(db.ConnectionString))
{
Assert.DoesNotThrow(conn.Open);
}
}
}
public void MakeTypeImplementing_ImplementedTypeShouldBeAbleToWrapTypeWithMethodWithArgsAndReturnValue()
{
//--------------- Arrange -------------------
var sut = Create();
var type = sut.MakeTypeImplementing <IArgsNonVoid>();
var toWrap = new ArgsNonVoidImpl();
var first = RandomValueGen.GetRandomInt();
var second = RandomValueGen.GetRandomInt();
var expected = toWrap.Add(first, second);
//--------------- Assume ----------------
//--------------- Act ----------------------
var instance = (IArgsNonVoid)CreateInstanceOf(type, new object[] { new[] { toWrap } });
var result = instance.Add(first, second);
//--------------- Assert -----------------------
Expect(result).To.Equal((expected));
}
MakeTypeImplementing_GivenInterfaceWithTwoReadOnlyProperties_ShouldProduceTypeWithWritableProperties()
{
//--------------- Arrange -------------------
var sut = Create();
var type = sut.MakeTypeImplementing <ISample2>();
var instance = (ISample2)CreateInstanceOf(type);
var expectedId = RandomValueGen.GetRandomInt();
var expectedName = RandomValueGen.GetRandomString();
//--------------- Assume ----------------
//--------------- Act ----------------------
instance.SetPropertyValue("Id", expectedId);
instance.SetPropertyValue("Name", expectedName);
//--------------- Assert -----------------------
Expect(instance.Id).To.Equal(expectedId);
Expect(instance.Name).To.Equal(expectedName);
}
public void Test_GetValue_ShouldGetValueFromBO()
{
//---------------Set up test pack-------------------
var propertyInfo = typeof(FakeBO).GetProperty("FakeBOName");
var expectedPropValue = RandomValueGen.GetRandomString();
var fakeBO = new FakeBO {
FakeBOName = expectedPropValue
};
var propDescriptor = new PropertyDescriptorPropInfo(propertyInfo);
//---------------Assert Precondition----------------
Assert.AreEqual(expectedPropValue, propertyInfo.GetValue(fakeBO, null));
Assert.AreEqual(expectedPropValue, fakeBO.FakeBOName);
//---------------Execute Test ----------------------
var actualValue = propDescriptor.GetValue(fakeBO);
//---------------Test Result -----------------------
Assert.AreEqual(expectedPropValue, actualValue);
}
public void Test_SetPropertyValue_ShouldSetBOPropsValue()
{
//---------------Set up test pack-------------------
ContactPersonTestBO contactPersonTestBO = new ContactPersonTestBO();
const string propName = "ReflectiveProp";
IBOPropertyMapper boPropertyMapper = new ReflectionPropertyMapper(propName)
{
BusinessObject = contactPersonTestBO
};
//---------------Assert Precondition----------------
Assert.IsNull(contactPersonTestBO.ReflectiveProp);
//---------------Execute Test ----------------------
var expectedPropValue = RandomValueGen.GetRandomString();
boPropertyMapper.SetPropertyValue(expectedPropValue);
//---------------Test Result -----------------------
Assert.AreEqual(expectedPropValue, contactPersonTestBO.ReflectiveProp);
}
public async Task GetKataAttemptLogs_GivenNoDuplicateAttemptName_ShouldMergeResults()
{
//---------------Set up test pack-------------------
var userName = RandomValueGen.GetRandomString();
var splunkSearch = Substitute.For <ISplunkSearch>();
splunkSearch.GetProgressMaxLevelResults(userName).Returns(info => CreateTask(DateTime.Now.AddDays(-2)));
splunkSearch.GetMaxLevelResults(userName).Returns(info => CreateTask(DateTime.Now.AddDays(-1)));
var logRepository = CreateLogRepository(splunkSearch);
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var attemptLogs = await logRepository.GetKataAttemptLogs(userName, 20);
//---------------Test Result -----------------------
Assert.IsNotNull(attemptLogs);
Assert.AreEqual(2, attemptLogs.Count);
}
public void SetPropertyValue_GivenKnownPropertyNameAndValidValue_ShouldSetProperty()
{
//--------------- Arrange -------------------
var data = new Dictionary <string, object>();
var expected = RandomValueGen.GetRandomInt();
var sut = Create(data, typeof(IHaveId));
//--------------- Assume ----------------
//--------------- Act ----------------------
Expect(() =>
sut.SetPropertyValue("Id", expected.ToString()))
.Not.To.Throw();
//--------------- Assert -----------------------
Expect(data)
.To.Contain.Key("Id")
.With.Value(expected);
}
