public void CreateAnalyzer_BadFileName_ReturnsFalse() { logan = new LogAnalyzer(); logan.Initialize(); bool valid = logan.IsValid("abc"); Assert.That(valid, Is.False); }
public void BadlyNamedTest() { LogAnalyzer log = new LogAnalyzer(); int result= log.GetLineCount("abc.txt"); const int COULD_NOT_READ_FILE = -100; Assert.AreEqual(COULD_NOT_READ_FILE,result); }
public void BadAssertMessage() { LogAnalyzer log = new LogAnalyzer(); int result= log.GetLineCount("abc.txt"); const int COULD_NOT_READ_FILE = -100; Assert.AreEqual(COULD_NOT_READ_FILE,result,"result was {0} instead of {1}",result,COULD_NOT_READ_FILE); }
public void TestingTheWrongThing_Add1And1_FailsFirst() { LogAnalyzer analyzer = new LogAnalyzer(); int sumResult = analyzer.Sum(1, 2); Assert.AreEqual(4,sumResult); }
public void Analyze_WhenExceptionThrown_EmailIsSent() { var mocks = new MockRepository(); var stubWebService = mocks.Stub<IWebService>(); var mockEmailSender = mocks.DynamicMock<IEmailSender>(); using (mocks.Record()) { stubWebService.LogError("Anything"); LastCall.Constraints(Is.Anything()); LastCall.Throw(new Exception("Fake Exception")); mockEmailSender.SendEmail("to", "subject", "Fake Exception"); } var logAnalyzer = new LogAnalyzer { EmailSender = mockEmailSender, WebService = stubWebService }; logAnalyzer.Analyze("abc.txt"); mocks.Verify(mockEmailSender); }
public void IsValidLogFileName_GoodExtentionLowerCase_ReturnsTrue() { LogAnalyzer logAnalyzer = new LogAnalyzer(); bool result = logAnalyzer.IsValidLogFileName("file_with_good_extension.slf"); Assert.True(result); }
public void IsValidFileName_GoodExtension_ReturnTrue(string fileName) { LogAnalyzer logAnalyzer = MakeAnalyzer(); bool result = logAnalyzer.IsValidLogFileName(fileName); Assert.True(result); }
public void IsValidLogFileName_InValidExtensions_ReturnsFalse(string fileName) { _analyzer = MakeAnalyzer(managerWillBevalid: false); bool result = _analyzer.IsValidLogFileName(fileName); Assert.IsFalse(result); }
public void IsValidFileName_BadExtension_ReturnsFalse() { LogAnalyzer analyzer = new LogAnalyzer(); bool result = analyzer.IsValidLogFileName("filewithbadextension.boo"); Assert.False(result); }
public void LogAnalyzer_ReturnsCorrectErrorCount() { var logAnalyzer = new LogAnalyzer(@"designpatterns\strategypattern\assets\log.json"); var errorCount = logAnalyzer.FindErrors().Count(); Assert.AreEqual(104, errorCount); }
public void IsValidLogFileName_EmptyFileName_Throws() { LogAnalyzer la = MakeAnalyzer(); var ex = Assert.Throws <ArgumentException>(() => la.IsValidLogFileName("")); StringAssert.Contains("filename has to be provided", ex.Message); }
public void IsValidFileName_EmptyFileName_ThrowsException() { LogAnalyzer logAnalyzer = MakeAnalyzer(); ArgumentException ex = Assert.Catch <ArgumentException>(() => logAnalyzer.IsValidLogFileName("")); StringAssert.Contains("filename has to be provided", ex.Message); }
public void Setup() { logan=new LogAnalyzer(); logan.Initialize(); fileInfo=new FileInfo("c:\\someFile.txt"); }
public void IsValidFileName_GoodExtension_ReturnFalse() { LogAnalyzer logAnalyzer = MakeAnalyzer(); bool result = logAnalyzer.IsValidLogFileName("filewithbadextension.foo"); Assert.False(result); }
public void IsValidLogFileName_WhenCalled_ChangesWasLastFileNameValid(string filename, bool expected) { LogAnalyzer la = MakeAnalyzer(managerWillBevalid: expected); la.IsValidLogFileName(filename); Assert.AreEqual(expected, la.WasLastFileNameValid); }
public void IsValidLogFileName_FileNameIsEmpty_ReturnTrueFluent() { LogAnalyzer la = MakeAnalyzer(); bool result = la.IsValidLogFileName("filewithbadextension.slf"); Assert.That(result == true); }
public void IsValidLogFileName_BadExtension_ReturnFalse() { LogAnalyzer analyzer = new LogAnalyzer(); bool result = analyzer.IsValidLogFileName("alabalaBadExtension.foo"); Assert.False(result); }
public void IsValidLogFileName_GoodExtensionUppercase_ReturnsTrue() { LogAnalyzer analyzer = new LogAnalyzer(); bool result = analyzer.IsValidLogFileName("filewithgoodextension.SLF"); Assert.True(result); }
public void IsValidLogFileName_BadExtension_ReturnsFalse() { LogAnalyzer analyzer = new LogAnalyzer(); bool result = analyzer.IsValidLogFileName("filewithbadextension.foo"); Assert.False(result); }
public void IsValidLogFileName_GoodExtensionUppercase_ReturnsTrue() { var analyzer = new LogAnalyzer(); var result = analyzer.IsValidLogFileName("filewithgoodextension.SLF"); Assert.IsTrue(result); }
public void IsValidLogFileName_ValidExtensions_ReturnsTrue(string file) { LogAnalyzer analyzer = new LogAnalyzer(); bool result = analyzer.IsValidLogFileName(file); Assert.True(result); }
public void IsValidLogFileName_VariousExtensions_ChecksThem(string file, bool expected) { LogAnalyzer analyzer = new LogAnalyzer(); bool result = analyzer.IsValidLogFileName(file); Assert.AreEqual(expected, result); }
public void IsValidLogFileName_ValidExtensions_ReturnsTrue(string file) { var analyzer = new LogAnalyzer(); var result = analyzer.IsValidLogFileName(file); Assert.IsTrue(result); }
public void IsValidLogFileName_VariousExtensions_ChecksThem(string file, bool expected) { var analyzer = new LogAnalyzer(); var result = analyzer.IsValidLogFileName(file); Assert.AreEqual(expected, result); }
public void IsValidLogFileName_WhenCalled_WasLastFileNameValid() { LogAnalyzer analyzer = new LogAnalyzer(); analyzer.IsValidLogFileName("falsefile.foo"); Assert.False(analyzer.WasLastFileNameValid); }
public void IsValidLogFileName_CategoryTest_ReturnTrue(string fileName) { LogAnalyzer la = MakeAnalyzer(); bool result = la.IsValidLogFileName(fileName); Assert.IsTrue(result); }
public void IsValidFileName_BadExtension_ReturnsFalse(string fileName) { var logAnalyzer = new LogAnalyzer(); var result = logAnalyzer.IsValidFileName(fileName); Assert.AreEqual(false, result); }
public void IsValidLogFileName_EmptyFileName_ThrowsFluent() { LogAnalyzer la = MakeAnalyzer(); var ex = Assert.Throws <ArgumentException>(() => la.IsValidLogFileName("")); Assert.That(ex.Message, Is.StringContaining("filename has to be provided")); }
public void IsValidLogFileName_FileNameIsEmpty_ThrowException() { LogAnalyzer logAnalyzer = MakeAnalyzer(); var ex = Assert.Catch <Exception>(() => logAnalyzer.IsValidLogFileName("")); StringAssert.Contains("filename has to be provided", ex.Message); }
public void IsValidLogFileName_WhenCalled_ChangesWasLastFileNameValid() { LogAnalyzer la = MakeAnalyzer(); la.IsValidLogFileName("badname.foo"); Assert.IsFalse(la.WasLastFileNameValid); }
public void IsValidLogFileNameTest_BadExtension_ReturnsFalse(string file) { LogAnalyzer analyzer = new LogAnalyzer(); bool result = analyzer.IsValidLogFileName(file); Assert.False(result); }
public void Initialize_WhenCalled_SetsDefaultDelimiterIsTabDelimiter3() { LogAnalyzer log = new LogAnalyzer(); Assert.AreEqual(null, log.GetInternalDefaultDelimiter()); log.Initialize(); Assert.AreEqual('\t', log.GetInternalDefaultDelimiter()); }
public void IsValidLogFileName_BadExtension_ReturnFalse() { var analyzer = new LogAnalyzer(); var actual = analyzer.IsValidLogFileName("filewithbadextension.foo"); Assert.IsFalse(actual); }
public void IsValidLogFileName_GoodExtension_ReturnsTrue(string filename, bool expected) { LogAnalyzer analyzer = CreateAnalyzer(); bool result = analyzer.IsValidLogFileName(filename); Assert.AreEqual(expected, result); }
public void IsValidLogFileName_EmptyFileName_Throws() { LogAnalyzer analyzer = CreateAnalyzer(); Exception ex = Assert.Catch <Exception>(() => analyzer.IsValidLogFileName("")); StringAssert.Contains("filename has to be provided", ex.Message); }
public void IsValidLogFileName_GoodExtensionLowercase_ReturnsTrue() { var analyzer = new LogAnalyzer(); var actual = analyzer.IsValidLogFileName("filewithgoodextension.slf"); Assert.IsTrue(actual); }
public void IsValidLogFileName_ValidExtensions_ReturnsTrue() { var analyzer = new LogAnalyzer(); var actual = analyzer.IsValidLogFileName(this.TestContext.DataRow[0].ToString()); Assert.IsTrue(actual); }
public void Analyze_EmptyFile_ThrowsException() { FakeTheLogger(); LogAnalyzer la = new LogAnalyzer(); la.Analyze("myemptyfile.txt"); //rest of test }
public void Analyze_EmptyFile_ThrowsException() { LoggingFacility.Logger = Substitute.For<ILogger>(); LogAnalyzer la = new LogAnalyzer(); la.Analyze("myemptyfile.txt"); //rest of test }
public void IsValidLogFileNameTest_EmptyFileName_Throws() { LogAnalyzer analyzer = new LogAnalyzer(); var ex = Assert.Catch<Exception>(() => analyzer.IsValidLogFileName("")); StringAssert.Contains("filename has to be provided", ex.Message); }
public void IsValidLogFileName_GoodExtensionLowercase_ReturnsTrue() { LogAnalyzer analyzer = new LogAnalyzer(); bool result = analyzer.IsValidLogFileName("filewithgoodextension.slf"); Assert.True(result); }
public void IsValidLogFileName_ValidExtension_ReturnTrue(string file) { LogAnalyzer analyzer = new LogAnalyzer(); bool result = analyzer.IsValidLogFileName(file); Assert.True(result); }
public void IsValidLogFileName_GoodExtensionUppercase_ReturnTrue() { var logAnalyzer = new LogAnalyzer(); bool result = logAnalyzer.IsValidLogFileName("filewithbadextension.SLF"); Assert.True(result); }
public void IsValidFileName_validFile_ReturnsTrue() { //arrange LogAnalyzer analyzer = new LogAnalyzer(); //act bool result = analyzer.IsValidLogFileName("whatever.slf"); //assert Assert.IsTrue(result, "filename should be valid!"); }
public void CreateAnalyzer_GoodNAmeAndBadNameUsage() { logan = new LogAnalyzer(); logan.Initialize(); bool valid = logan.IsValid("abc"); Assert.That(valid, Is.False); CreateAnalyzer_GoodFileName_ReturnsTrue(); }
public void WhenAnalyze_ShouldReturnTooShortFileName() { var mockService = new MockService(); var log = new LogAnalyzer(mockService); string tooShortFileName = "abc.ext"; log.Analyze(tooShortFileName); Assert.That(mockService.LastError, Is.EqualTo("Filename too short:abc.ext")); }
public void Analyze_SimpleStringLine_UsesDefaulTabDelimiterToParseFields() { LogAnalyzer log = new LogAnalyzer(); AnalyzedOutput output = log.Analyze("10:05\tOpen\tRoy"); Assert.AreEqual(1,output.LineCount); Assert.AreEqual("10:05",output.GetLine(1)[0]); Assert.AreEqual("Open",output.GetLine(1)[1]); Assert.AreEqual("Roy",output.GetLine(1)[2]); }
public void Analyze_SimpleStringLine_UsesDefaulTabDelimiterToParseFields2() { LogAnalyzer log = new LogAnalyzer(); AnalyzedOutput expected = new AnalyzedOutput(); expected.AddLine("10:05", "Open", "Roy"); AnalyzedOutput output = log.Analyze("10:05\tOpen\tRoy"); Assert.AreEqual(expected,output); }
public void Analyze_ShortFileName_LogsError() { var mockWebService = new MockWebService(); var logAnalyzer = new LogAnalyzer { WebService = mockWebService }; logAnalyzer.Analyze("abc.txt"); Assert.AreEqual(mockWebService.LogText, "Short FileName:abc.txt"); }
public void WhenAnalyze_ShouldReturnTooShortFileName_WithMock() { var mockService = new Mock<IWebService>(MockBehavior.Strict); string tooShortFileName = "abc.ext"; mockService.Setup(x => x.LogError("Filename too short:abc.ext")).Verifiable(); var log = new LogAnalyzer(mockService.Object); log.Analyze(tooShortFileName); //Assert.That(strLastError, Is.EqualTo("Filename too short:abc.ext")); mockService.Verify(x => x.LogError("Filename too short:abc.ext")); //mockService.Verify(x => x.LogError(It.IsAny<string>())); }
public void Analyze_ShortFileName_LogsError() { var mocks = new MockRepository(); var mockWebService = mocks.DynamicMock<IWebService>(); using (mocks.Record()) { mockWebService.LogError("Short FileName:abc.txt"); } var logAnalyzer = new LogAnalyzer { WebService = mockWebService }; logAnalyzer.Analyze("abc.txt"); mocks.Verify(mockWebService); }
private LogAnalyzer GetNewAnalyzer() { LogAnalyzer analyzer = new LogAnalyzer(); analyzer.Initialize(); return analyzer; }
private LogAnalyzer MakeAnalyzer() { var logAnalyzer = new LogAnalyzer(); return logAnalyzer; }
//[ExpectedException] public void WhenAnalyze_ShouldReturnTooShortFileName_WithCallback() { //Arrange var mockService = new Mock<IWebService>(MockBehavior.Strict); string strLastError = ""; string tooShortFileName = "abc.ext"; mockService.Setup(x => x.LogError(It.IsAny<string>( ))) .Callback( (string error) => { strLastError = error; } ); //mockService.Setup(x => x.LogError("Tsest")).Throws(new ArgumentException()); var log = new LogAnalyzer(mockService.Object); //Act log.Analyze(tooShortFileName); //Assert Assert.That(strLastError, Is.EqualTo("Filename too short:abc.ext")); }
private LogAnalyzer MakeDefaultAnalyzer() { LogAnalyzer analyzer = new LogAnalyzer(); analyzer.Initialize(); return analyzer; }
public void Setup() { m_analyzer = new LogAnalyzer(); myDate = new DateTime(2006,12,28,5,32,0); }
public void Setup() { m_analyzer = new LogAnalyzer(); }
public void TearDown() { m_analyzer = null; }