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); }