public void JobLoggerCanLogAcceptedMessageTypes()
{
JobLogger jl = JobLogger.Instance;
jl.Reset();
StubLogger consoleLogger = new StubConsoleLogger();
List <ILogger> loggers = new List <ILogger>
{
consoleLogger
};
jl.SetLoggers(loggers);
jl.AcceptMessages <ErrorMessage>();
Assert.AreEqual(0, consoleLogger.Output.Count);
jl.LogMessage(new GeneralMessage("This general message should not be logged."));
Assert.AreEqual(0, consoleLogger.Output.Count);
jl.LogMessage(new ErrorMessage("This error message should be logged."));
Assert.AreEqual(1, consoleLogger.Output.Count);
Assert.AreEqual("This error message should be logged.", consoleLogger.Output[0]);
}
public void JobLoggerCanLogToAllLoggers()
{
string msg_text1 = "This is a general message 1";
string msg_text2 = "This is a general message 2";
string msg_text3 = "This is a general message 3";
string msg_text4 = "This is a general message 4";
JobLogger jl = JobLogger.Instance;
StubLogger consoleLogger = new StubConsoleLogger();
StubLogger textFileLogger = new StubTextFileLogger();
StubLogger dbLogger = new StubDBLogger();
//Log two time to console logger
List <ILogger> loggers = new List <ILogger>
{
consoleLogger,
consoleLogger,
textFileLogger,
dbLogger
};
List <Type> acceptedMessages = new List <Type>
{
typeof(GeneralMessage),
};
jl.SetLoggers(loggers);
jl.AcceptMessages <GeneralMessage>();
Assert.AreEqual(0, consoleLogger.Output.Count);
Assert.AreEqual(0, textFileLogger.Output.Count);
Assert.AreEqual(0, dbLogger.Output.Count);
jl.LogMessage(new GeneralMessage(msg_text1));
jl.LogMessage(new GeneralMessage(msg_text2));
jl.LogMessage(new GeneralMessage(msg_text3));
jl.LogMessage(new GeneralMessage(msg_text4));
Assert.AreEqual(8, consoleLogger.Output.Count);
Assert.AreEqual(4, textFileLogger.Output.Count);
Assert.AreEqual(4, dbLogger.Output.Count);
CollectionAssert.AreEqual(new List <string> {
msg_text1, msg_text1, msg_text2, msg_text2, msg_text3, msg_text3, msg_text4, msg_text4
}, consoleLogger.Output);
CollectionAssert.AreEqual(new List <string> {
msg_text1, msg_text2, msg_text3, msg_text4
}, textFileLogger.Output);
CollectionAssert.AreEqual(new List <string> {
msg_text1, msg_text2, msg_text3, msg_text4
}, dbLogger.Output);
}
public void LogMessage_SameLoggerAndMessage_CallLogger()
{
var message = "test message";
var mock = new Mock <ILogger>();
jobLogger.AddLogger(mock.Object);
jobLogger.AddLogCategory(LogCategory.Message);
jobLogger.LogMessage(LogCategory.Message, message);
mock.Verify(x => x.LogMessage(LogCategory.Message, message), Times.Once);
}
public void LogMessageIdAppendedInLog()
{
try
{
int totalLog = 0;
string filePath = ConfigurationManager.AppSettings["Log_FileDirectory"];
string fecha = DateTime.Today.ToString("yyyyMMdd");
string path = Path.Combine(filePath, string.Concat("LogFile", fecha, ".txt"));
if (File.Exists(path))
{
string[] messages = File.ReadAllLines(path);
totalLog = messages.Length;
}
JobLogger.LogMessage(LogType.Message, LogTarget.File, "Inserting message log for testing");
string[] messagesAfterLogging = File.ReadAllLines(path);
if (totalLog + 1 != messagesAfterLogging.Length)
{
Assert.Fail("Not inserting new log record");
}
}
catch (Exception exc)
{
Assert.Fail(exc.Message);
}
}
public void JobLoggerCanAggregateLoggersExceptions()
{
JobLogger jl = JobLogger.Instance;
jl.Reset();
StubLogger consoleLogger1 = new StubConsoleLogger();
StubLogger consoleLogger2 = new StubConsoleLogger();
StubLogger exceptionLogger1 = new StubExceptionThrowingLogger();
StubLogger exceptionLogger2 = new StubExceptionThrowingLogger();
StubLogger exceptionLogger3 = new StubExceptionThrowingLogger();
List <ILogger> loggers = new List <ILogger>
{
exceptionLogger1,
consoleLogger1,
exceptionLogger2,
consoleLogger2,
exceptionLogger3
};
jl.SetLoggers(loggers);
jl.AcceptMessages <ErrorMessage>();
jl.LogMessage(new ErrorMessage("Error message."));
}
public void DatabaseErrorLog()
{
JobLogger.LogToDatabase();
JobLogger.EnableMessageLog();
var message = "Test error";
var statement = "[" + LogType.Error.ToString() + "] : " + message;
JobLogger.LogMessage(message, LogType.Error);
SqlConnection connection = new SqlConnection(ConfigurationManager.AppSettings["ConnectionString"]);
connection.Open();
SqlCommand command = new SqlCommand("SELECT LogDescription FROM dbo.Log ORDER BY Id DESC LIMIT 1;");
var lastRecord = "";
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
lastRecord = reader[0].ToString();
}
}
Assert.AreEqual(statement, lastRecord);
}
private static void SaveLogToFile()
{
MessageType[] onlyShow = { MessageType.Error, MessageType.Message, MessageType.Warning };
var log = new JobLogger(LogToTarget.File, onlyShow);
log.LogMessage("a", MessageType.Warning);
}
public void LogMessage_WhenCalled_ThrowNotImplementedException()
{
// Arrange => Act
JobLogger.LogMessage(LogLevel.Message, "This is a info message");
// Assert - ExpectedException
}
public void TestEmptyMessage()
{
var kindOfLogs = new KindOfLogs();
kindOfLogs.LogToConsole = true;
Assert.IsFalse(JobLogger.LogMessage(" ", KindOfError.Error, kindOfLogs));
}
public void LogMessage_MessageIsNull_ThrowArgNullException()
{
MessageType[] onlyShow = { MessageType.Error, MessageType.Message, MessageType.Warning };
var log = new JobLogger(LogToTarget.Console, onlyShow);
Assert.That(() => log.LogMessage(null, MessageType.Error), Throws.ArgumentNullException);
}
public void TestMethod1()
{
bool _logToDatabase = false;
bool _logToFile = true;
bool _logToConsole = false;
string message = "This is an error message test.";
bool _logMessage = false;
bool isMessage = false;
bool _logWarning = true;
bool warning = true;
bool _logError = false;
bool error = false;
int isComplete = 0;
try
{
JobLogger log = new JobLogger(_logToFile, _logToConsole, _logToDatabase, _logMessage, _logWarning, _logError);
JobLogger.LogMessage(message, isMessage, warning, error);
isComplete = 1;
}
catch (Exception)
{
isComplete = -1;
}
Assert.AreEqual(1, isComplete);
}
public void ExcepcionTodosNuull()
{
JobLogger instruccion = new JobLogger(false, false, false, false, false, false);
JobLogger.LogMessage("error ! soy un mensaje de error", true, false, false);
}
static void Main(string[] args)
{
Helper helper = new Helper();
JobLogger log = new JobLogger(1, "Hi World", helper);
log.LogMessage();
}
public void LogearErrorConsola()
{
// JobLogger( logToFile, logToConsole, logToDatabase, logMessage, logWarning, logError)
JobLogger instruccion = new JobLogger(false, true, false, false, false, true);
Assert.AreEqual(JobLogger.LogMessage("error ! soy un mensaje de error", false, false, true), true);
}
private static void ShowErrorOnConsole()
{
MessageType[] onlyShow = { MessageType.Error, MessageType.Message, MessageType.Warning };
var log = new JobLogger(LogToTarget.Console, onlyShow);
log.LogMessage("a", MessageType.Error);
}
public void TestLogDataBase()
{
var kindOfLogs = new KindOfLogs();
kindOfLogs.LogToDatabase = true;
Assert.IsTrue(JobLogger.LogMessage("mensaje", KindOfError.Error, kindOfLogs));
}
public void TestDataBaseAndFile_MarkWarning()
{
JobLogger _JobLogger = new JobLogger(true, false, true, true, true, true);
Result _Result = _JobLogger.LogMessage("Mensaje de prueba", false, true, false);
Assert.NotNull(_Result);
Assert.That(_Result.Code, Is.EqualTo((int)Enumerates.Result.Success));
}
public void WriteWarningTest()
{
JobLogger C1 = retornarLogger(configLogger.soloWarnings);
int expectedResponse = 1;
Assert.AreEqual(expectedResponse, C1.LogMessage("Warning Test", LogType.Warning));
}
public void WriteErrorTest()
{
JobLogger C1 = retornarLogger(configLogger.soloErrores);
int expectedResponse = 1;
Assert.AreEqual(expectedResponse, C1.LogMessage("Error Test", LogType.Error));
}
public void WriteMessageTest()
{
JobLogger C1 = retornarLogger(configLogger.soloMensajes);
int expectedResponse = 1;
Assert.AreEqual(expectedResponse, C1.LogMessage("Message Test", LogType.Message));
}
static void Main(string[] args)
{
string[] tiposMensajes = { "ERROR", "WARNING", "MESSAGE" };
string[] tiposLogs = { "CONSOLE", "FILE", "BD" };
JobLogger.LogMessage("probando", tiposLogs, tiposMensajes);
Console.ReadLine();
}
public void LogMessageToConsoleTest()
{
var jobLogger = new JobLogger(false, true, false, true, true, true);
jobLogger.LogMessage("Test Message.", true, false, false);
Assert.IsTrue(true);
}
public void Test_WithOutSetAnyMarker()
{
JobLogger _JobLogger = new JobLogger(true, true, true, false, false, false);
Result _Result = _JobLogger.LogMessage("mensaje", false, true, false);
Assert.NotNull(_Result);
Assert.That(_Result.Code, Is.EqualTo((int)Enumerates.Result.Error));
}
static void Main(string[] args)
{
JobLogger.LogMessage("Hello", LogType.Message);
JobLogger.LogMessage("Hello", LogType.Error);
JobLogger.LogMessage("Hello", LogType.Warning);
Console.ReadLine();
}
static void Main(string[] args)
{
/*
* Setting up Dependency Injection
*/
ConfigureInstallers();
ConfigureConsole();
/*
* Building Logger Manager Class, Creating Message And Logging it.
*/
try
{
var messageFactory = container.Resolve <MessageFactory>();
var builder = container.Resolve <JobLoggerBuilder>();
JobLogger logger = builder.EnableConsoleLog()
.EnableDatabaseLog()
.EnableFileLog()
.EnableInfoMessage()
.EnableErrorMessage()
.EnableWarningMessage()
.Build();
Message message1 = messageFactory.Create("Test Info Message", EnumMessageType.INFO);
Message message2 = messageFactory.Create("Test Warn Message", EnumMessageType.WARNING);
Message message3 = messageFactory.Create("Test Error Message", EnumMessageType.ERROR);
Message nullMessage = messageFactory.Create(string.Empty, EnumMessageType.ERROR);
logger.LogMessage(message1);
logger.LogMessage(message2);
logger.LogMessage(message3);
logger.LogMessage(nullMessage);
}
catch (JobLoggerConfigurationException ex)
{
System.Console.WriteLine(string.Format("Error Ocurred: {0}", ex.Message));
}
catch (System.Exception ex2)
{
System.Console.WriteLine(string.Format("System Error: {0}", ex2.Message));
}
System.Console.WriteLine("Closing Belatrix Console...");
System.Console.ReadKey();
}
public void TestMethod1()
{
const string message = "Inicio de sesión con éxito";
const bool message2 = true;
const bool warning = true;
const bool error = true;
JobLogger.LogMessage(message, message2, warning, error);
}
static void Main(string[] args)
{
//Run Example
var jobLogger = new JobLogger(logToFile: false, logToConsole: true, logToDatabase: false);
jobLogger.LogMessage("Test", JobLogger.MessageType.WARNING);
Console.ReadKey();
}
public void LogMessageEmptyTest()
{
//arrange
JobLogger log = new JobLogger(1, String.Empty, helper.Object);
//act
log.LogMessage();
//assert
}
public void LogMessageNullTest()
{
//arrange
JobLogger log = new JobLogger(1, null, helper.Object);
//act
log.LogMessage();
//assert
}
public void ReciboMensajeYquieroErrorPorArchivo()
{
// JobLogger( logToFile, logToConsole, logToDatabase, logMessage, logWarning, logError)
JobLogger instruccion = new JobLogger(true, false, false, false, true, false);
//Devuelve True porque yo TENGO un mensaje pero quiero solo guardar por archivo los ERRORES.
//Entonces no se llega a ejecutar nunca el Save File. ( Lo evalua y no lo hace, e imprime true)
Assert.AreEqual(JobLogger.LogMessage("Mensaje ! soy un mensaje ", true, false, false), true);
}