diff --git a/src/RulesEngine/RulesEngine/Models/CompiledRule.cs b/src/RulesEngine/RulesEngine/Models/CompiledRule.cs
index e919f1a..6d18a71 100644
--- a/src/RulesEngine/RulesEngine/Models/CompiledRule.cs
+++ b/src/RulesEngine/RulesEngine/Models/CompiledRule.cs
@@ -3,9 +3,11 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 
 namespace RulesEngine.Models
 {
+    [ExcludeFromCodeCoverage]
     internal class CompiledRule
     {
         /// <summary>
diff --git a/src/RulesEngine/RulesEngine/Models/Rule.cs b/src/RulesEngine/RulesEngine/Models/Rule.cs
index 0cd6dbc..db1aa9f 100644
--- a/src/RulesEngine/RulesEngine/Models/Rule.cs
+++ b/src/RulesEngine/RulesEngine/Models/Rule.cs
@@ -4,12 +4,14 @@
 using Newtonsoft.Json;
 using Newtonsoft.Json.Converters;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 
 namespace RulesEngine.Models
 {
     /// <summary>
     /// Rule class
     /// </summary>
+    [ExcludeFromCodeCoverage]
     public class Rule
     {
         /// <summary>
diff --git a/src/RulesEngine/RulesEngine/Models/RuleResultTree.cs b/src/RulesEngine/RulesEngine/Models/RuleResultTree.cs
index 8037f69..2649031 100644
--- a/src/RulesEngine/RulesEngine/Models/RuleResultTree.cs
+++ b/src/RulesEngine/RulesEngine/Models/RuleResultTree.cs
@@ -3,12 +3,14 @@
 
 using RulesEngine.HelperFunctions;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 
 namespace RulesEngine.Models
 {
     /// <summary>
     /// Rule result class with child result heirarchy
     /// </summary>
+    [ExcludeFromCodeCoverage]
     public class RuleResultTree
     {
         /// <summary>
@@ -49,6 +51,7 @@ namespace RulesEngine.Models
         /// This method will return all the error and warning messages to caller
         /// </summary>
         /// <returns>RuleResultMessage</returns>
+        [ExcludeFromCodeCoverage]
         public RuleResultMessage GetMessages()
         {
             RuleResultMessage ruleResultMessage = new RuleResultMessage();
@@ -62,6 +65,7 @@ namespace RulesEngine.Models
     /// <summary>
     /// This class will hold the error messages
     /// </summary>
+    [ExcludeFromCodeCoverage]
     public class RuleResultMessage
     {
         /// <summary>
diff --git a/src/RulesEngine/RulesEngine/Models/WorkflowRules.cs b/src/RulesEngine/RulesEngine/Models/WorkflowRules.cs
index 50cee5a..f6db30f 100644
--- a/src/RulesEngine/RulesEngine/Models/WorkflowRules.cs
+++ b/src/RulesEngine/RulesEngine/Models/WorkflowRules.cs
@@ -2,12 +2,14 @@
 // Licensed under the MIT License.
 
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 
 namespace RulesEngine.Models
 {
     /// <summary>
     /// Workflow rules class for deserialization  the json config file
     /// </summary>
+    [ExcludeFromCodeCoverage]
     public class WorkflowRules
     {
         /// <summary>
diff --git a/src/RulesEngine/RulesEngine/RulesEngine.csproj b/src/RulesEngine/RulesEngine/RulesEngine.csproj
index 15e582d..09b613a 100644
--- a/src/RulesEngine/RulesEngine/RulesEngine.csproj
+++ b/src/RulesEngine/RulesEngine/RulesEngine.csproj
@@ -2,6 +2,13 @@
 
   <PropertyGroup>
     <TargetFramework>netstandard2.0</TargetFramework>
+    <Version>2.0.0</Version>
+    <Copyright>Copyright (c) Microsoft Corporation.</Copyright>
+    <PackageLicenseFile>LICENSE</PackageLicenseFile>
+    <PackageProjectUrl>https://github.com/microsoft/RulesEngine</PackageProjectUrl>
+    <Authors>Dishant Munjal, Abbas Cyclewala, Yogesh Prajapati</Authors>
+    <Description>Rules Engine is a package for abstracting business logic/rules/policies out of the system. This works in a very simple way by giving you an ability to put your rules in a store outside the core logic of the system thus ensuring that any change in rules doesn't affect the core system.</Description>
+    <PackageTags>BRE, Rules Engine, Abstraction</PackageTags>
   </PropertyGroup>
 
   <ItemGroup>
@@ -13,4 +20,11 @@
     <PackageReference Include="System.Linq.Dynamic.Core" Version="1.0.18" />
   </ItemGroup>
 
+  <ItemGroup>
+    <None Include="..\..\..\LICENSE">
+      <Pack>True</Pack>
+      <PackagePath></PackagePath>
+    </None>
+  </ItemGroup>
+
 </Project>
diff --git a/test/RulesEngine.UnitTest/ListofRuleResultTreeExtensionTest.cs b/test/RulesEngine.UnitTest/ListofRuleResultTreeExtensionTest.cs
new file mode 100644
index 0000000..acf1f82
--- /dev/null
+++ b/test/RulesEngine.UnitTest/ListofRuleResultTreeExtensionTest.cs
@@ -0,0 +1,215 @@
+using RulesEngine.Extensions;
+using RulesEngine.Models;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Xunit;
+
+namespace RulesEngine.UnitTest
+{
+    [Trait("Category", "Unit")]
+    public class ListofRuleResultTreeExtensionTest
+    {
+        [Fact]
+        public void OnSuccessWithSuccessTest()
+        {
+            var rulesResultTree = new List<RuleResultTree>()
+            {
+                new RuleResultTree()
+                {
+                    ChildResults = null,
+                    ExceptionMessage = string.Empty,
+                    Input = new object(),
+                    IsSuccess = true,
+                    Rule = new Rule()
+                    {
+                        RuleName = "Test Rule 1"
+                    }
+                },
+                new RuleResultTree()
+                {
+                    ChildResults = null,
+                    ExceptionMessage = string.Empty,
+                    Input = new object(),
+                    IsSuccess = false,
+                    Rule = new Rule()
+                    {
+                        RuleName = "Test Rule 2"
+                    }
+                },
+
+            };
+
+            var successEventName = string.Empty;
+
+            rulesResultTree.OnSuccess((eventName) =>
+            {
+                successEventName = eventName;
+            });
+
+            Assert.True(successEventName.Equals("Test Rule 1"));
+        }
+
+        [Fact]
+        public void OnSuccessWithSuccessWithEventTest()
+        {
+            var rulesResultTree = new List<RuleResultTree>()
+            {
+                new RuleResultTree()
+                {
+                    ChildResults = null,
+                    ExceptionMessage = string.Empty,
+                    Input = new object(),
+                    IsSuccess = true,
+                    Rule = new Rule()
+                    {
+                        RuleName = "Test Rule 1",
+                        SuccessEvent = "Event 1"
+                    }
+                },
+                new RuleResultTree()
+                {
+                    ChildResults = null,
+                    ExceptionMessage = string.Empty,
+                    Input = new object(),
+                    IsSuccess = false,
+                    Rule = new Rule()
+                    {
+                        RuleName = "Test Rule 2"
+                    }
+                },
+
+            };
+
+            var successEventName = string.Empty;
+
+            rulesResultTree.OnSuccess((eventName) =>
+            {
+                successEventName = eventName;
+            });
+
+            Assert.True(successEventName.Equals("Event 1"));
+        }
+
+        [Fact]
+        public void OnSuccessWithouSuccessTest()
+        {
+            var rulesResultTree = new List<RuleResultTree>()
+            {
+                new RuleResultTree()
+                {
+                    ChildResults = null,
+                    ExceptionMessage = string.Empty,
+                    Input = new object(),
+                    IsSuccess = false,
+                    Rule = new Rule()
+                    {
+                        RuleName = "Test Rule 1"
+                    }
+                },
+                new RuleResultTree()
+                {
+                    ChildResults = null,
+                    ExceptionMessage = string.Empty,
+                    Input = new object(),
+                    IsSuccess = false,
+                    Rule = new Rule()
+                    {
+                        RuleName = "Test Rule 2"
+                    }
+                },
+
+            };
+
+            var successEventName = string.Empty;
+
+            rulesResultTree.OnSuccess((eventName) =>
+            {
+                successEventName = eventName;
+            });
+
+            Assert.True(successEventName.Equals(string.Empty));
+        }
+
+
+        [Fact]
+        public void OnFailWithSuccessTest()
+        {
+            var rulesResultTree = new List<RuleResultTree>()
+            {
+                new RuleResultTree()
+                {
+                    ChildResults = null,
+                    ExceptionMessage = string.Empty,
+                    Input = new object(),
+                    IsSuccess = true,
+                    Rule = new Rule()
+                    {
+                        RuleName = "Test Rule 1"
+                    }
+                },
+                new RuleResultTree()
+                {
+                    ChildResults = null,
+                    ExceptionMessage = string.Empty,
+                    Input = new object(),
+                    IsSuccess = false,
+                    Rule = new Rule()
+                    {
+                        RuleName = "Test Rule 2"
+                    }
+                },
+
+            };
+
+            var successEventName = true;
+
+            rulesResultTree.OnFail(() =>
+            {
+                successEventName = false;
+            });
+
+            Assert.True(successEventName);
+        }
+
+        [Fact]
+        public void OnFailWithoutSuccessTest()
+        {
+            var rulesResultTree = new List<RuleResultTree>()
+            {
+                new RuleResultTree()
+                {
+                    ChildResults = null,
+                    ExceptionMessage = string.Empty,
+                    Input = new object(),
+                    IsSuccess = false,
+                    Rule = new Rule()
+                    {
+                        RuleName = "Test Rule 1"
+                    }
+                },
+                new RuleResultTree()
+                {
+                    ChildResults = null,
+                    ExceptionMessage = string.Empty,
+                    Input = new object(),
+                    IsSuccess = false,
+                    Rule = new Rule()
+                    {
+                        RuleName = "Test Rule 2"
+                    }
+                },
+
+            };
+
+            var successEventName = true;
+
+            rulesResultTree.OnFail(() =>
+            {
+                successEventName = false;
+            });
+
+            Assert.False(successEventName);
+        }
+    }
+}
diff --git a/test/RulesEngine.UnitTest/NullLoggerTests.cs b/test/RulesEngine.UnitTest/NullLoggerTests.cs
deleted file mode 100644
index 4b09040..0000000
--- a/test/RulesEngine.UnitTest/NullLoggerTests.cs
+++ /dev/null
@@ -1,44 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-
-using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Logging.Abstractions;
-using System;
-using Xunit;
-
-namespace RulesEngine.UnitTest
-{
-    [Trait("Category","Unit")]
-    public class NullLoggerTest
-    {
-        [Fact]
-        public void NullLogger_BeginScope_DoesNotThrow()
-        {
-            var logger = new NullLogger<RulesEngine>();
-
-            using (logger.BeginScope("test-value"))
-            { }
-        }
-
-        [Theory]
-        [InlineData(LogLevel.Critical)]
-        [InlineData(LogLevel.Debug)]
-        [InlineData(LogLevel.Error)]
-        [InlineData(LogLevel.Information)]
-        [InlineData(LogLevel.None)]
-        [InlineData(LogLevel.Trace)]
-        [InlineData(LogLevel.Warning)]
-        public void NullLogger_IsEnabled_ReturnsTrue(LogLevel logLevel)
-        {
-            var logger = new NullLogger<RulesEngine>();
-            logger.IsEnabled(logLevel).Equals(true);
-        }
-
-        [Fact]
-        public void NullLogger_Log_DoesNotThrow() 
-        {
-            var logger = new NullLogger<RulesEngine>();
-            logger.Log(LogLevel.Critical, 1, "This is a critical message.");
-        }
-    }
-}
\ No newline at end of file