public void TestReconfiguration() { RollbarLoggerConfig config = new RollbarLoggerConfig(); Assert.AreEqual("seedToken", config.RollbarDestinationOptions.AccessToken); Console.WriteLine(config.TraceAsString()); config.Reconfigured += Config_Reconfigured; Assert.AreEqual(0, this._actualReconfigCount); IRollbarDestinationOptions rollbarDestinationOptions = config.RollbarDestinationOptions; RollbarDestinationOptions destinationOptions = new RollbarDestinationOptions(); destinationOptions.AccessToken = "CUSTOM"; config.RollbarDestinationOptions.Reconfigure(destinationOptions); Assert.AreEqual(1, this._actualReconfigCount); Assert.AreSame(rollbarDestinationOptions, config.RollbarDestinationOptions); Assert.AreEqual("CUSTOM", config.RollbarDestinationOptions.AccessToken, "Options reconfig works!"); Console.WriteLine(config.TraceAsString()); RollbarLoggerConfig newConfig = new RollbarLoggerConfig(); Assert.AreEqual("seedToken", newConfig.RollbarDestinationOptions.AccessToken); Console.WriteLine(newConfig.TraceAsString()); Assert.AreNotSame(rollbarDestinationOptions, newConfig.RollbarDestinationOptions); newConfig.Reconfigured += Config_Reconfigured; rollbarDestinationOptions = newConfig.RollbarDestinationOptions; newConfig.Reconfigure(config); Assert.AreEqual(8, this._actualReconfigCount); Assert.AreEqual("CUSTOM", newConfig.RollbarDestinationOptions.AccessToken, "Structured config's reconfig works!"); Console.WriteLine(newConfig.TraceAsString()); Assert.AreSame(rollbarDestinationOptions, newConfig.RollbarDestinationOptions); Assert.AreNotSame(config, newConfig); Assert.AreNotSame(config.RollbarDestinationOptions, newConfig.RollbarDestinationOptions); }
public void TestGetSafeScrubFields() { var scrubFields = new string[] { "one", "two", "three", }; var scrubSafelistFields = new string[] { "two", }; var expectedSafeScrubFields = new string[] { "one", "three", }; var destinationOptions = new RollbarDestinationOptions(RollbarUnitTestSettings.AccessToken, RollbarUnitTestSettings.Environment); var dataSecurityOptions = new RollbarDataSecurityOptions(); dataSecurityOptions.ScrubFields = scrubFields; dataSecurityOptions.ScrubSafelistFields = scrubSafelistFields; var loggerConfig = new RollbarLoggerConfig(RollbarUnitTestSettings.AccessToken); loggerConfig.RollbarDestinationOptions.Reconfigure(destinationOptions); loggerConfig.RollbarDataSecurityOptions.Reconfigure(dataSecurityOptions); var result = loggerConfig.RollbarDataSecurityOptions.GetFieldsToScrub(); Assert.AreEqual(expectedSafeScrubFields.Length, result.Count); foreach (var expected in expectedSafeScrubFields) { Assert.IsTrue(result.Contains(expected)); } }
public void TestBasics() { RollbarDestinationOptions options = new RollbarDestinationOptions(); Console.WriteLine(options.TraceAsString()); Assert.AreEqual(null, options.AccessToken, "AccessToken is null!"); var results = options.Validate(); Assert.AreEqual(1, results.Count, "One Validation Rule failed!"); Console.WriteLine("Validation Results:"); foreach (var result in results) { Console.WriteLine($" {result}"); } Console.WriteLine(); options.AccessToken = "ACCESS_TOKEN"; Console.WriteLine(options.TraceAsString()); Assert.AreEqual("ACCESS_TOKEN", options.AccessToken, "Expected AccessToken"); results = options.Validate(); Assert.AreEqual(0, results.Count, "No Validation Rule failed!"); Console.WriteLine("Validation Results:"); foreach (var result in results) { Console.WriteLine($" {result}"); } Console.WriteLine(); }
public PayloadFixture() { RollbarDestinationOptions destinationOptions = new RollbarDestinationOptions(RollbarUnitTestSettings.AccessToken, RollbarUnitTestSettings.Environment); this._config = new RollbarLoggerConfig(); this._config.RollbarDestinationOptions.Reconfigure(destinationOptions); }
public void ConvenienceMethodsUseAppropriateErrorLevels(ErrorLevel expectedLogLevel) { var acctualLogLevel = ErrorLevel.Info; void Transform(Payload payload) { acctualLogLevel = payload.Data.Level.Value; } RollbarDestinationOptions destinationOptions = new RollbarDestinationOptions( RollbarUnitTestSettings.AccessToken, RollbarUnitTestSettings.Environment ); RollbarPayloadManipulationOptions payloadManipulationOptions = new RollbarPayloadManipulationOptions(Transform); var loggerConfig = new RollbarLoggerConfig(); loggerConfig.RollbarDestinationOptions.Reconfigure(destinationOptions); loggerConfig.RollbarPayloadManipulationOptions.Reconfigure(payloadManipulationOptions); using (var logger = RollbarFactory.CreateNew().Configure(loggerConfig)) { try { var blockingLogger = logger.AsBlockingLogger(TimeSpan.FromMilliseconds(TIME_OUT)); var ex = new Exception(); switch (expectedLogLevel) { case ErrorLevel.Critical: blockingLogger.Critical(ex); break; case ErrorLevel.Error: blockingLogger.Error(ex); break; case ErrorLevel.Warning: blockingLogger.Warning(ex); break; case ErrorLevel.Info: blockingLogger.Info(ex); break; case ErrorLevel.Debug: blockingLogger.Debug(ex); break; } } catch { Assert.Fail(); } } Assert.AreEqual(expectedLogLevel, acctualLogLevel); }
public static RollbarDestinationOptions GetLiveTestRollbarDestinationOptions() { var options = new RollbarDestinationOptions( RollbarUnitTestSettings.AccessToken, RollbarUnitTestSettings.Environment ); return(options); }
public void SetupFixture() { SynchronizationContext.SetSynchronizationContext(new SynchronizationContext()); RollbarDestinationOptions destinationOptions = new RollbarDestinationOptions( RollbarUnitTestSettings.AccessToken, RollbarUnitTestSettings.Environment ); this._loggerConfig = new RollbarLoggerConfig(); this._loggerConfig.RollbarDestinationOptions.Reconfigure(destinationOptions); }
/// <summary> /// Provides configuration for RollbarSink. /// </summary> /// <param name="loggerConfiguration">The logger configuration.</param> /// <param name="rollbarAccessToken">The Rollbar access token.</param> /// <param name="rollbarEnvironment">The Rollbar environment.</param> /// <param name="rollbarBlockingLoggingTimeout">The Rollbar blocking logging timeout.</param> /// <param name="formatProvider">The format provider.</param> /// <param name="restrictedToMinimumLevel"> /// The minimum level for events passed through the sink. Ignored when <paramref name="levelSwitch"/> is specified. /// </param> /// <param name="levelSwitch">A switch allowing the pass-through minimum level to be changed at runtime.</param> /// <returns>LoggerConfiguration.</returns> public static LoggerConfiguration RollbarSink( this LoggerSinkConfiguration loggerConfiguration, string rollbarAccessToken, string rollbarEnvironment, TimeSpan?rollbarBlockingLoggingTimeout, IFormatProvider?formatProvider, LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum, LoggingLevelSwitch?levelSwitch = null ) { RollbarDestinationOptions destinationOptions = new RollbarDestinationOptions(rollbarAccessToken, rollbarEnvironment); IRollbarInfrastructureConfig config = new RollbarInfrastructureConfig(); config.RollbarLoggerConfig.RollbarDestinationOptions.Reconfigure(destinationOptions); return(loggerConfiguration.RollbarSink(config, rollbarBlockingLoggingTimeout, formatProvider, restrictedToMinimumLevel, levelSwitch)); }
/// <summary> /// Provides the live rollbar configuration. /// </summary> /// <param name="rollbarAccessToken">The rollbar access token.</param> /// <param name="rollbarEnvironment">The rollbar environment.</param> /// <returns>IRollbarConfig.</returns> protected IRollbarLoggerConfig ProvideLiveRollbarConfig(string rollbarAccessToken, string rollbarEnvironment) { if (this._loggerConfig == null) { RollbarDestinationOptions destinationOptions = new RollbarDestinationOptions(rollbarAccessToken, rollbarEnvironment); RollbarDataSecurityOptions dataSecurityOptions = new RollbarDataSecurityOptions(); dataSecurityOptions.ScrubFields = new string[] { "secret", "super_secret", }; RollbarLoggerConfig loggerConfig = new RollbarLoggerConfig(); loggerConfig.RollbarDestinationOptions.Reconfigure(destinationOptions); loggerConfig.RollbarDataSecurityOptions.Reconfigure(dataSecurityOptions); this._loggerConfig = loggerConfig; } return(this._loggerConfig); }
public void ReconfigureRollbarTest() { RollbarDestinationOptions destinationOptions = new RollbarDestinationOptions( RollbarUnitTestSettings.AccessToken, RollbarUnitTestSettings.Environment ); RollbarLoggerConfig loggerConfig1 = new RollbarLoggerConfig(); loggerConfig1.RollbarDestinationOptions.Reconfigure(destinationOptions); destinationOptions.AccessToken = RollbarUnitTestSettings.AccessToken.Replace('0', '1'); RollbarLoggerConfig loggerConfig2 = new RollbarLoggerConfig(); loggerConfig2.RollbarDestinationOptions.Reconfigure(destinationOptions); Assert.AreNotEqual(loggerConfig1.RollbarDestinationOptions.AccessToken, loggerConfig2.RollbarDestinationOptions.AccessToken); int initialCount = RollbarQueueController.Instance.GetQueuesCount(); int initialCount1 = RollbarQueueController.Instance.GetQueuesCount(loggerConfig1.RollbarDestinationOptions.AccessToken); int initialCount2 = RollbarQueueController.Instance.GetQueuesCount(loggerConfig2.RollbarDestinationOptions.AccessToken); Assert.AreEqual(initialCount + 0, RollbarQueueController.Instance.GetQueuesCount()); Assert.AreEqual(initialCount1 + 0, RollbarQueueController.Instance.GetQueuesCount(loggerConfig1.RollbarDestinationOptions.AccessToken)); Assert.AreEqual(initialCount2 + 0, RollbarQueueController.Instance.GetQueuesCount(loggerConfig2.RollbarDestinationOptions.AccessToken)); using (var logger1 = RollbarFactory.CreateNew().Configure(loggerConfig1)) { Assert.AreEqual(initialCount + 1, RollbarQueueController.Instance.GetQueuesCount()); Assert.AreEqual(initialCount1 + 1, RollbarQueueController.Instance.GetQueuesCount(loggerConfig1.RollbarDestinationOptions.AccessToken)); Assert.AreEqual(initialCount2 + 0, RollbarQueueController.Instance.GetQueuesCount(loggerConfig2.RollbarDestinationOptions.AccessToken)); logger1.Configure(loggerConfig2); Assert.AreEqual(initialCount + 1, RollbarQueueController.Instance.GetQueuesCount()); Assert.AreEqual(initialCount1 + 0, RollbarQueueController.Instance.GetQueuesCount(loggerConfig1.RollbarDestinationOptions.AccessToken)); Assert.AreEqual(initialCount2 + 1, RollbarQueueController.Instance.GetQueuesCount(loggerConfig2.RollbarDestinationOptions.AccessToken)); } }
public void ExceptionWhileTransformingPayloadAsync() { this._transformException = false; RollbarDestinationOptions destinationOptions = new RollbarDestinationOptions( RollbarUnitTestSettings.AccessToken, RollbarUnitTestSettings.Environment ); RollbarLoggerConfig loggerConfig = new RollbarLoggerConfig(); loggerConfig.RollbarDestinationOptions.Reconfigure(destinationOptions); RollbarPayloadManipulationOptions payloadManipulationOptions = new RollbarPayloadManipulationOptions(); payloadManipulationOptions.Transform = delegate { throw new NullReferenceException(); }; loggerConfig.RollbarPayloadManipulationOptions.Reconfigure(payloadManipulationOptions); using IRollbar logger = RollbarFactory.CreateNew().Configure(loggerConfig); logger.InternalEvent += Logger_InternalEvent; try { this.IncrementCount <CommunicationEventArgs>(); logger.Log(ErrorLevel.Error, "test message"); } catch { logger.InternalEvent -= Logger_InternalEvent; Assert.Fail("should never get here!"); throw; } this._signal.Wait(); logger.InternalEvent -= Logger_InternalEvent; Assert.IsTrue(this._transformException); }
public void MultithreadedStressTest_BlockingLogs() { RollbarLoggerFixture.stressLogsCount = 0; RollbarDestinationOptions destinationOptions = new RollbarDestinationOptions( RollbarUnitTestSettings.AccessToken, RollbarUnitTestSettings.Environment ); RollbarLoggerConfig loggerConfig = new RollbarLoggerConfig(); loggerConfig.RollbarDestinationOptions.Reconfigure(destinationOptions); RollbarInfrastructureOptions infrastructureOptions = new RollbarInfrastructureOptions(); infrastructureOptions.ReportingQueueDepth = 200; RollbarInfrastructure.Instance.Config.RollbarInfrastructureOptions.Reconfigure(infrastructureOptions); this.IncrementCount <CommunicationEventArgs>(RollbarInfrastructure.Instance.Config.RollbarInfrastructureOptions.ReportingQueueDepth); TimeSpan rollbarBlockingTimeout = TimeSpan.FromMilliseconds(55000); List <IRollbar> rollbars = new List <IRollbar>(MultithreadedStressTestParams.TotalThreads); List <ILogger> loggers = new List <ILogger>(MultithreadedStressTestParams.TotalThreads); for (int i = 0; i < MultithreadedStressTestParams.TotalThreads; i++) { var rollbar = RollbarFactory.CreateNew().Configure(loggerConfig); loggers.Add(rollbar.AsBlockingLogger(rollbarBlockingTimeout)); rollbars.Add(rollbar); } PerformTheMultithreadedStressTest(loggers.ToArray()); rollbars.ForEach(r => { r.Dispose(); }); }
public void BasicPayloadBundleTest() { const int totalExceptionFrames = 5; System.Exception exceptionObj = ExceptionSimulator.GetExceptionWith(totalExceptionFrames); IRollbarPackage package = new ObjectPackage(exceptionObj, true); Assert.IsTrue(package.MustApplySynchronously); Assert.IsNull(package.RollbarData); //var rollbarData = package.PackageAsRollbarData(); //Assert.AreSame(rollbarData, package.RollbarData); RollbarDestinationOptions destinationOptions = new RollbarDestinationOptions("ACCESS_TOKEN", "ENV"); IRollbarLoggerConfig config = infrastructureConfig.RollbarLoggerConfig; config.RollbarDestinationOptions.Reconfigure(destinationOptions); using (IRollbar rollbarLogger = RollbarFactory.CreateNew(config)) { PayloadBundle bundle = new PayloadBundle(rollbarLogger as RollbarLogger, package, ErrorLevel.Critical); var payload = bundle.GetPayload(); } }
public void LongReportIsAsync() { const int maxCallLengthInMillisec = 50; TimeSpan payloadSubmissionDelay = TimeSpan.FromMilliseconds(3 * maxCallLengthInMillisec); RollbarDestinationOptions destinationOptions = new RollbarDestinationOptions( RollbarUnitTestSettings.AccessToken, RollbarUnitTestSettings.Environment ); RollbarLoggerConfig loggerConfig = new RollbarLoggerConfig(); loggerConfig.RollbarDestinationOptions.Reconfigure(destinationOptions); RollbarPayloadManipulationOptions payloadManipulationOptions = new RollbarPayloadManipulationOptions(); payloadManipulationOptions.Transform = delegate { Thread.Sleep(payloadSubmissionDelay); }; loggerConfig.RollbarPayloadManipulationOptions.Reconfigure(payloadManipulationOptions); using IRollbar logger = RollbarFactory.CreateNew().Configure(loggerConfig); try { this.IncrementCount <CommunicationEventArgs>(); Stopwatch sw = Stopwatch.StartNew(); logger.Log(ErrorLevel.Error, "test message"); sw.Stop(); Assert.IsTrue(sw.ElapsedMilliseconds < maxCallLengthInMillisec); Thread.Sleep(payloadSubmissionDelay); } catch { Assert.Fail("should never get here!"); } }
public void QueueRegisterationTest() { Console.WriteLine($"Unrealeased queues count: {RollbarQueueController.Instance.GetUnReleasedQueuesCount()}"); // we need to make sure we are starting clean: RollbarQueueController.Instance.FlushQueues(); RollbarQueueController.Instance.Stop(true); RollbarQueueController.Instance.Start(); //while (RollbarQueueController.Instance.GetQueuesCount() > 0) //{ // Thread.Sleep(TimeSpan.FromMilliseconds(250)); //} Console.WriteLine($"Unreleased queues count: {RollbarQueueController.Instance.GetUnReleasedQueuesCount()}"); RollbarDestinationOptions destinationOptions = new RollbarDestinationOptions( RollbarUnitTestSettings.AccessToken, RollbarUnitTestSettings.Environment ); RollbarLoggerConfig loggerConfig1 = new RollbarLoggerConfig(); loggerConfig1.RollbarDestinationOptions.Reconfigure(destinationOptions); destinationOptions.AccessToken = RollbarUnitTestSettings.AccessToken.Replace('0', '1'); RollbarLoggerConfig loggerConfig2 = new RollbarLoggerConfig(); loggerConfig2.RollbarDestinationOptions.Reconfigure(destinationOptions); Console.WriteLine($"Unreleased queues count: {RollbarQueueController.Instance.GetUnReleasedQueuesCount()}"); Assert.AreNotEqual(loggerConfig1.RollbarDestinationOptions.AccessToken, loggerConfig2.RollbarDestinationOptions.AccessToken); int initialCount = RollbarQueueController.Instance.GetQueuesCount(); int initialCount1 = RollbarQueueController.Instance.GetQueuesCount(loggerConfig1.RollbarDestinationOptions.AccessToken); int initialCount2 = RollbarQueueController.Instance.GetQueuesCount(loggerConfig2.RollbarDestinationOptions.AccessToken); Assert.AreEqual(initialCount + 0, RollbarQueueController.Instance.GetQueuesCount()); Assert.AreEqual(initialCount1 + 0, RollbarQueueController.Instance.GetQueuesCount(loggerConfig1.RollbarDestinationOptions.AccessToken)); Assert.AreEqual(initialCount2 + 0, RollbarQueueController.Instance.GetQueuesCount(loggerConfig2.RollbarDestinationOptions.AccessToken)); using (var logger1 = RollbarFactory.CreateNew().Configure(loggerConfig1)) { Assert.AreEqual(initialCount + 1, RollbarQueueController.Instance.GetQueuesCount()); Assert.AreEqual(initialCount1 + 1, RollbarQueueController.Instance.GetQueuesCount(loggerConfig1.RollbarDestinationOptions.AccessToken)); Assert.AreEqual(initialCount2 + 0, RollbarQueueController.Instance.GetQueuesCount(loggerConfig2.RollbarDestinationOptions.AccessToken)); using (var logger2 = RollbarFactory.CreateNew().Configure(loggerConfig1)) { Assert.AreEqual(initialCount + 2, RollbarQueueController.Instance.GetQueuesCount()); Assert.AreEqual(initialCount1 + 2, RollbarQueueController.Instance.GetQueuesCount(loggerConfig1.RollbarDestinationOptions.AccessToken)); Assert.AreEqual(initialCount2 + 0, RollbarQueueController.Instance.GetQueuesCount(loggerConfig2.RollbarDestinationOptions.AccessToken)); using (var logger3 = RollbarFactory.CreateNew().Configure(loggerConfig2)) { Assert.AreEqual(initialCount + 3, RollbarQueueController.Instance.GetQueuesCount()); Assert.AreEqual(initialCount1 + 2, RollbarQueueController.Instance.GetQueuesCount(loggerConfig1.RollbarDestinationOptions.AccessToken)); Assert.AreEqual(initialCount2 + 1, RollbarQueueController.Instance.GetQueuesCount(loggerConfig2.RollbarDestinationOptions.AccessToken)); } // an unused queue does not get removed immediately (but eventually) - so let's wait for it for a few processing cycles: while ((initialCount + 2) != RollbarQueueController.Instance.GetQueuesCount()) { Thread.Sleep(TimeSpan.FromMilliseconds(250)); } // if everything is good, we should get here way before this test method times out: Assert.AreEqual(initialCount + 2, RollbarQueueController.Instance.GetQueuesCount()); Assert.AreEqual(initialCount1 + 2, RollbarQueueController.Instance.GetQueuesCount(loggerConfig1.RollbarDestinationOptions.AccessToken)); Assert.AreEqual(initialCount2 + 0, RollbarQueueController.Instance.GetQueuesCount(loggerConfig2.RollbarDestinationOptions.AccessToken)); } // an unused queue does not get removed immediately (but eventually) - so let's wait for it for a few processing cycles: while ((initialCount + 1) != RollbarQueueController.Instance.GetQueuesCount()) { Thread.Sleep(TimeSpan.FromMilliseconds(250)); } // if everything is good, we should get here way before this test method times out: Assert.AreEqual(initialCount + 1, RollbarQueueController.Instance.GetQueuesCount()); Assert.AreEqual(initialCount1 + 1, RollbarQueueController.Instance.GetQueuesCount(loggerConfig1.RollbarDestinationOptions.AccessToken)); Assert.AreEqual(initialCount2 + 0, RollbarQueueController.Instance.GetQueuesCount(loggerConfig2.RollbarDestinationOptions.AccessToken)); } // an unused queue does not get removed immediately (but eventually) - so let's wait for it for a few processing cycles: while ((initialCount + 0) != RollbarQueueController.Instance.GetQueuesCount()) { Console.WriteLine($"Unreleased queues count: {RollbarQueueController.Instance.GetUnReleasedQueuesCount()}"); Thread.Sleep(TimeSpan.FromMilliseconds(250)); } // if everything is good, we should get here way before this test method times out: Assert.AreEqual(initialCount + 0, RollbarQueueController.Instance.GetQueuesCount()); Assert.AreEqual(initialCount1 + 0, RollbarQueueController.Instance.GetQueuesCount(loggerConfig1.RollbarDestinationOptions.AccessToken)); Assert.AreEqual(initialCount2 + 0, RollbarQueueController.Instance.GetQueuesCount(loggerConfig2.RollbarDestinationOptions.AccessToken)); }
public void ScopedInstanceTest() { // we need to make sure we are starting clean: RollbarQueueController.Instance.FlushQueues(); RollbarQueueController.Instance.Start(); var accessTokenQueues = RollbarQueueController.Instance.GetQueues(RollbarUnitTestSettings.AccessToken); while (accessTokenQueues.Any()) { string msg = "Initial queues count: " + accessTokenQueues.Count(); System.Diagnostics.Trace.WriteLine(msg); Console.WriteLine(msg); foreach (var queue in accessTokenQueues) { msg = "---Payloads in a queue: " + queue.GetPayloadCount(); System.Diagnostics.Trace.WriteLine(msg); Console.WriteLine(msg); if (!queue.IsReleased) { queue.Release(); } else { queue.Flush(); } } Thread.Sleep(TimeSpan.FromMilliseconds(250)); accessTokenQueues = RollbarQueueController.Instance.GetQueues(RollbarUnitTestSettings.AccessToken); } RollbarDestinationOptions destinationOptions = new RollbarDestinationOptions( RollbarUnitTestSettings.AccessToken, RollbarUnitTestSettings.Environment ); RollbarLoggerConfig loggerConfig = new RollbarLoggerConfig(); loggerConfig.RollbarDestinationOptions.Reconfigure(destinationOptions); int totalInitialQueues = RollbarQueueController.Instance.GetQueuesCount(RollbarUnitTestSettings.AccessToken); using (var logger = RollbarFactory.CreateNew().Configure(loggerConfig)) { Assert.AreEqual(totalInitialQueues + 1, RollbarQueueController.Instance.GetQueuesCount(RollbarUnitTestSettings.AccessToken)); this.IncrementCount <CommunicationEventArgs>(); logger.Log(ErrorLevel.Error, "test message"); } // an unused queue does not get removed immediately (but eventually) - so let's wait for it for a few processing cycles: int currentQueuesCount = RollbarQueueController.Instance.GetQueuesCount(RollbarUnitTestSettings.AccessToken); while (totalInitialQueues != currentQueuesCount) { string msg = "Current queues count: " + currentQueuesCount + " while initial count was: " + totalInitialQueues; System.Diagnostics.Trace.WriteLine(msg); Console.WriteLine(msg); Thread.Sleep(TimeSpan.FromMilliseconds(250)); currentQueuesCount = RollbarQueueController.Instance.GetQueuesCount(RollbarUnitTestSettings.AccessToken); } // if everything is good, we should get here way before this test method times out: Assert.AreEqual(totalInitialQueues, RollbarQueueController.Instance.GetQueuesCount(RollbarUnitTestSettings.AccessToken)); }
public void ConvenienceMethodsUseAppropriateErrorLevels(ErrorLevel expectedLogLevel) { var awaitAsyncSend = new ManualResetEventSlim(false); var acctualLogLevel = ErrorLevel.Info; void Transform(Payload payload) { acctualLogLevel = payload.Data.Level.Value; awaitAsyncSend.Set(); } RollbarDestinationOptions destinationOptions = new RollbarDestinationOptions( RollbarUnitTestSettings.AccessToken, RollbarUnitTestSettings.Environment ); RollbarLoggerConfig loggerConfig = new RollbarLoggerConfig(); loggerConfig.RollbarDestinationOptions.Reconfigure(destinationOptions); RollbarPayloadManipulationOptions payloadManipulationOptions = new RollbarPayloadManipulationOptions(); payloadManipulationOptions.Transform = Transform; loggerConfig.RollbarPayloadManipulationOptions.Reconfigure(payloadManipulationOptions); this.IncrementCount <CommunicationEventArgs>(); using (var logger = RollbarFactory.CreateNew().Configure(loggerConfig)) { try { //TODO: implement and add SynchronousPackage around the payload object!!! var ex = new Exception(); switch (expectedLogLevel) { case ErrorLevel.Critical: logger.Critical(ex); break; case ErrorLevel.Error: logger.Error(ex); break; case ErrorLevel.Warning: logger.Warning(ex); break; case ErrorLevel.Info: logger.Info(ex); break; case ErrorLevel.Debug: logger.Debug(ex); break; } } catch { Assert.Fail("should never reach here!"); } } awaitAsyncSend.Wait(); Assert.AreEqual(expectedLogLevel, acctualLogLevel); }
public void TestRollbarConfigEqualityMethod() { RollbarDestinationOptions destinationOptions = new RollbarDestinationOptions("12345", "env1"); RollbarLoggerConfig rConfig = new RollbarLoggerConfig(); rConfig.RollbarDestinationOptions.Reconfigure(destinationOptions); // test the same config instance references: Assert.IsTrue(rConfig.Equals(rConfig), "Same instances are always equal."); destinationOptions = new RollbarDestinationOptions("12345", "env1"); // same as rConfig... RollbarLoggerConfig rConfigSimilar = new RollbarLoggerConfig(); rConfigSimilar.RollbarDestinationOptions.Reconfigure(destinationOptions); destinationOptions = new RollbarDestinationOptions("12345", "env2"); RollbarLoggerConfig rConfigOneDiff = new RollbarLoggerConfig(); destinationOptions = new RollbarDestinationOptions("02345", "env1"); RollbarLoggerConfig rConfigAnotherDiff = new RollbarLoggerConfig(); destinationOptions = new RollbarDestinationOptions("02345", "env2"); RollbarLoggerConfig rConfigTwoDiffs = new RollbarLoggerConfig(); destinationOptions = new RollbarDestinationOptions("12345", null); RollbarLoggerConfig rConfigOneNullifed = new RollbarLoggerConfig(); // test different config instances simple properties: Assert.IsTrue(rConfig.Equals(rConfigSimilar), "Simple properties: Similar instances are always equal."); Assert.IsFalse(rConfig.Equals(rConfigOneDiff), "Simple properties: One different property value makes unequal."); Assert.IsFalse(rConfig.Equals(rConfigAnotherDiff), "Simple properties: Another different property value makes unequal."); Assert.IsFalse(rConfig.Equals(rConfigTwoDiffs), "Simple properties: Multiple different property values make unequal."); Assert.IsFalse(rConfig.Equals(rConfigOneNullifed), "Simple properties: Nullified property of one config instance makes unequal."); // test structured/complex properties: Person person = new Person() { UserName = "******", Email = "*****@*****.**", }; Person personSimilar = new Person() { UserName = "******", Email = "*****@*****.**", }; Person personOneDiff = new Person() { UserName = "******", Email = "*****@*****.**", }; Person personOneNull = new Person() { UserName = "******", Email = null, }; RollbarPayloadAdditionOptions additionOptions = new RollbarPayloadAdditionOptions(); additionOptions.Person = person; rConfig.RollbarPayloadAdditionOptions.Reconfigure(additionOptions); Assert.IsTrue(rConfig.Equals(rConfig), "Structured properties: Same instances are always equal."); additionOptions.Person = person; rConfigSimilar.RollbarPayloadAdditionOptions.Reconfigure(additionOptions); Assert.IsTrue(rConfig.Equals(rConfigSimilar), "Structured properties: Similar #1 instances are always equal."); additionOptions.Person = personSimilar; rConfigSimilar.RollbarPayloadAdditionOptions.Reconfigure(additionOptions); Assert.IsTrue(rConfig.Equals(rConfigSimilar), "Structured properties: Similar #2 instances are always equal."); additionOptions.Person = personOneDiff; rConfigSimilar.RollbarPayloadAdditionOptions.Reconfigure(additionOptions); Assert.IsFalse(rConfig.Equals(rConfigSimilar), "Structured properties: One different property value makes unequal."); additionOptions.Person = personOneNull; rConfigSimilar.RollbarPayloadAdditionOptions.Reconfigure(additionOptions); Assert.IsFalse(rConfig.Equals(rConfigSimilar), "Structured properties: Nullified property of one config instance makes unequal."); }