Esempio n. 1
0
        public void TestCustomCollectionPathsNoFormatType()
        {
            Arguments     arg         = new Arguments(new [] { "-c", "test.txt" });
            List <string> addtlPaths  = new List <string>();
            List <string> paths       = new List <string>();
            string        sep         = "/";
            var           userProfile = Environment.ExpandEnvironmentVariables("%HOME%");
            var           logger      = new CyLR.Logger();

            logger.LoggingOptions["output_file_path"] = "4.log";
            logger.Setup();

            if (!Platform.IsUnixLike())
            {
                sep         = "\\";
                userProfile = Environment.ExpandEnvironmentVariables("%USERPROFILE%");
            }

            paths.Add(userProfile + sep + "not_a_filename___");
            using (StreamWriter sr = new StreamWriter("test.txt"))
            {
                sr.WriteLine("\t" + userProfile + sep + "not_a_filename___");
                sr.WriteLine("force " + userProfile + sep + "not_a_filename___");
            }

            var cPaths = CollectionPaths.GetPaths(arg, addtlPaths, false, logger);

            paths.Sort();
            cPaths.Sort();
            Assert.NotEqual(paths, cPaths);
            Assert.Empty(cPaths);
        }
Esempio n. 2
0
        public void TestLoggerLevelConfigs()
        {
            var logger = new CyLR.Logger();

            // Defaults
            logger.Setup();

            Assert.Equal(CyLR.Logger.Level.trace, logger.fileLevel);
            Assert.Equal(CyLR.Logger.Level.info, logger.consoleLevel);
            logger.TearDown();

            // Warn and Error
            logger.LoggingOptions["output_file_min_level"]    = "warn";
            logger.LoggingOptions["output_console_min_level"] = "error";

            logger.Setup();

            Assert.Equal(CyLR.Logger.Level.warn, logger.fileLevel);
            Assert.Equal(CyLR.Logger.Level.error, logger.consoleLevel);
            logger.TearDown();

            // Error and Warn
            logger.LoggingOptions["output_file_min_level"]    = "error";
            logger.LoggingOptions["output_console_min_level"] = "warn";

            logger.Setup();

            Assert.Equal(CyLR.Logger.Level.error, logger.fileLevel);
            Assert.Equal(CyLR.Logger.Level.warn, logger.consoleLevel);

            // Test each of the levels for both output formats
            List <CyLR.Logger.Level> levels = new List <CyLR.Logger.Level> {
                CyLR.Logger.Level.trace,
                CyLR.Logger.Level.debug,
                CyLR.Logger.Level.info,
                CyLR.Logger.Level.warn,
                CyLR.Logger.Level.error,
                CyLR.Logger.Level.critical,
                CyLR.Logger.Level.none
            };

            logger.TearDown();

            foreach (var l in levels)
            {
                logger.LoggingOptions["output_file_min_level"]    = l.ToString();
                logger.LoggingOptions["output_console_min_level"] = l.ToString();

                logger.Setup();

                Assert.Equal(l, logger.fileLevel);
                Assert.Equal(l, logger.consoleLevel);

                logger.TearDown();
            }
        }
Esempio n. 3
0
        public void TestCustomCollectionPaths()
        {
            Arguments     arg         = new Arguments(new [] { "-c", "test.txt" });
            List <string> addtlPaths  = new List <string>();
            List <string> paths       = new List <string>();
            string        sep         = "/";
            var           userProfile = Environment.ExpandEnvironmentVariables("%HOME%");
            var           logger      = new CyLR.Logger();

            logger.LoggingOptions["output_file_path"]         = "1.log";
            logger.LoggingOptions["output_console_min_level"] = "error";
            logger.Setup();

            // Set platform specific variables.
            if (!Platform.IsUnixLike())
            {
                sep         = "\\";
                userProfile = Environment.ExpandEnvironmentVariables("%USERPROFILE%");
            }

            // Define expected test files
            paths.Add(userProfile + sep + "CyLR_test.file");
            paths.Add(userProfile + sep + "CyLR_glob_test");
            paths.Add(userProfile + sep + "CyLR_Regex_test");

            // Create test files
            foreach (var path in paths)
            {
                if (!File.Exists(path))
                {
                    File.Create(path);
                }
            }

            // Create custom patterns file.
            using (StreamWriter sr = new StreamWriter("test.txt"))
            {
                sr.WriteLine("glob\t**" + sep + "CyLR_glob_test");
                sr.WriteLine("static\t" + userProfile + sep + "CyLR_test.file");
                if (Platform.IsUnixLike())
                {
                    sr.WriteLine("regex\t^" + userProfile + sep + "CyLR_[A-Za-z]{5}_test$");
                }
                else
                {
                    sr.WriteLine("regex\t^" + userProfile.Replace("\\", "\\\\") + sep + sep + "CyLR_[A-Za-z]{5}_test$");
                }
            }

            var cPaths = CollectionPaths.GetPaths(arg, addtlPaths, false, logger);

            paths.Sort();
            cPaths.Sort();
            Assert.Equal(paths, cPaths);
        }
Esempio n. 4
0
        public void TestLoggerLevelMessages()
        {
            var    logger = new CyLR.Logger();
            string expected;
            string actual;

            logger.Setup();

            logger.trace("This is a trace!");
            expected = "[trace] This is a trace!\n";
            actual   = logger.logMessages.Split(" ", 2)[1];
            Assert.Equal(expected, actual);
            logger.logMessages = "";

            logger.debug("This is a debug!");
            expected = "[debug] This is a debug!\n";
            actual   = logger.logMessages.Split(" ", 2)[1];
            Assert.Equal(expected, actual);
            logger.logMessages = "";

            logger.info("This is a info!");
            expected = "[info] This is a info!\n";
            actual   = logger.logMessages.Split(" ", 2)[1];
            Assert.Equal(expected, actual);
            logger.logMessages = "";

            logger.warn("This is a warning!");
            expected = "[warn] This is a warning!\n";
            actual   = logger.logMessages.Split(" ", 2)[1];
            Assert.Equal(expected, actual);
            logger.logMessages = "";

            logger.error("This is a error!");
            expected = "[error] This is a error!\n";
            actual   = logger.logMessages.Split(" ", 2)[1];
            Assert.Equal(expected, actual);
            logger.logMessages = "";

            logger.critical("This is a critical!");
            expected = "[critical] This is a critical!\n";
            actual   = logger.logMessages.Split(" ", 2)[1];
            Assert.Equal(expected, actual);
            logger.logMessages = "";

            logger.none("This is a none!");
            expected = "[none] This is a none!\n";
            actual   = logger.logMessages.Split(" ", 2)[1];
            Assert.Equal(expected, actual);

            logger.TearDown();
        }
Esempio n. 5
0
        public void TestLoggerLevelMessages()
        {
            var    logger = new CyLR.Logger();
            var    now    = DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ss");
            string expected;

            logger.Setup();

            logger.trace("This is a trace!");
            now      = DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ss");
            expected = $"{now} [trace] This is a trace!\n";
            Assert.Equal(expected, logger.logMessages);
            logger.logMessages = "";

            logger.debug("This is a debug!");
            now      = DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ss");
            expected = $"{now} [debug] This is a debug!\n";
            Assert.Equal(expected, logger.logMessages);
            logger.logMessages = "";

            logger.info("This is a info!");
            now      = DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ss");
            expected = $"{now} [info] This is a info!\n";
            Assert.Equal(expected, logger.logMessages);
            logger.logMessages = "";

            logger.warn("This is a warning!");
            now      = DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ss");
            expected = $"{now} [warn] This is a warning!\n";
            Assert.Equal(expected, logger.logMessages);
            logger.logMessages = "";

            logger.error("This is a error!");
            now      = DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ss");
            expected = $"{now} [error] This is a error!\n";
            Assert.Equal(expected, logger.logMessages);
            logger.logMessages = "";

            logger.critical("This is a critical!");
            now      = DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ss");
            expected = $"{now} [critical] This is a critical!\n";
            Assert.Equal(expected, logger.logMessages);
            logger.logMessages = "";

            logger.none("This is a none!");
            now      = DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ss");
            expected = $"{now} [none] This is a none!\n";
            Assert.Equal(expected, logger.logMessages);

            logger.TearDown();
        }
Esempio n. 6
0
        public void TestLoggerFormats()
        {
            var logger = new CyLR.Logger();

            logger.Setup();

            logger.logger(CyLR.Logger.Level.warn, "This is a warning!");
            var expected = "[warn] This is a warning!\n";
            var actual   = logger.logMessages.Split(" ", 2)[1];

            Assert.Equal(expected, actual);

            logger.TearDown();
        }
Esempio n. 7
0
        public void TestLoggerFormats()
        {
            var logger = new CyLR.Logger();

            logger.Setup();

            logger.logger(CyLR.Logger.Level.warn, "This is a warning!");
            var now      = DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ss");
            var expected = $"{now} [warn] This is a warning!\n";

            Assert.Equal(expected, logger.logMessages);

            logger.TearDown();
        }
Esempio n. 8
0
        public void TestCustomCollectionPathsRegExFail()
        {
            Arguments     arg         = new Arguments(new [] { "-c", "test.txt" });
            List <string> addtlPaths  = new List <string>();
            List <string> paths       = new List <string>();
            string        sep         = "/";
            var           userProfile = Environment.ExpandEnvironmentVariables("%HOME%");
            var           logger      = new CyLR.Logger();

            logger.LoggingOptions["output_file_path"] = "2.log";
            logger.Setup();

            if (!Platform.IsUnixLike())
            {
                sep         = "\\";
                userProfile = Environment.ExpandEnvironmentVariables("%USERPROFILE%");
            }

            paths.Add(userProfile + sep + "CyLR_Regex_test");
            using (StreamWriter sr = new StreamWriter("test.txt"))
            {
                if (Platform.IsUnixLike())
                {
                    sr.WriteLine("regex\t^" + userProfile + sep + "CyLR_[A-Za-z]{10}_test$");
                }
                else
                {
                    sr.WriteLine("regex\t^" + userProfile.Replace("\\", "\\\\") + sep + sep + "CyLR_[A-Za-z]{10}_test$");
                }
            }

            // Create test files
            foreach (var path in paths)
            {
                if (!File.Exists(path))
                {
                    File.Create(path);
                }
            }

            var cPaths = CollectionPaths.GetPaths(arg, addtlPaths, false, logger);

            paths.Sort();
            cPaths.Sort();
            Assert.NotEqual(paths, cPaths);
            Assert.Empty(cPaths);
        }