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 CreateAnalyzer_BadFileName_ReturnsFalse()
{
logan = new LogAnalyzer();
logan.Initialize();
bool valid = logan.IsValid("abc");
Assert.That(valid, Is.False);
}
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;
}
