From fea57c7632df04d2961aaa6349f56e91c2a5a23b Mon Sep 17 00:00:00 2001
From: sriv <srikanth.ddit@gmail.com>
Date: Mon, 21 Mar 2016 14:19:02 +0530
Subject: [PATCH] scan gauge_additional_libs, some refactoring, fixes #58

---
 ...ScannerTests.cs => AssemblyLoaderTests.cs} |  27 ++--
 Runner.UnitTests/AssemblyLocaterTests.cs      | 137 ++++++++++++++++++
 .../Gauge.CSharp.Runner.UnitTests.csproj      |   6 +-
 Runner.UnitTests/HookRegistryTests.cs         |   4 +-
 .../{AssemblyScanner.cs => AssemblyLoader.cs} |  15 +-
 Runner/AssemblyLocater.cs                     |  80 ++++++++++
 Runner/DefaultScreenGrabber.cs                |  17 +++
 Runner/Gauge.CSharp.Runner.csproj             |  16 +-
 Runner/HookRegistry.cs                        |   6 +-
 ...IAssemblyScanner.cs => IAssemblyLoader.cs} |   4 +-
 Runner/IAssemblyLocater.cs                    |  26 ++++
 Runner/Sandbox.cs                             |  24 +--
 Runner/{ => Wrappers}/AssemblyWrapper.cs      |   2 +-
 Runner/Wrappers/DirectoryWrapper.cs           |  35 +++++
 Runner/{ => Wrappers}/FileWrapper.cs          |   2 +-
 Runner/{ => Wrappers}/IAssemblyWrapper.cs     |   2 +-
 Runner/Wrappers/IDirectoryWrapper.cs          |  28 ++++
 Runner/{ => Wrappers}/IFileWrapper.cs         |   2 +-
 18 files changed, 387 insertions(+), 46 deletions(-)
 rename Runner.UnitTests/{AssemblyScannerTests.cs => AssemblyLoaderTests.cs} (74%)
 create mode 100644 Runner.UnitTests/AssemblyLocaterTests.cs
 rename Runner/{AssemblyScanner.cs => AssemblyLoader.cs} (90%)
 create mode 100644 Runner/AssemblyLocater.cs
 rename Runner/{IAssemblyScanner.cs => IAssemblyLoader.cs} (86%)
 create mode 100644 Runner/IAssemblyLocater.cs
 rename Runner/{ => Wrappers}/AssemblyWrapper.cs (96%)
 create mode 100644 Runner/Wrappers/DirectoryWrapper.cs
 rename Runner/{ => Wrappers}/FileWrapper.cs (95%)
 rename Runner/{ => Wrappers}/IAssemblyWrapper.cs (95%)
 create mode 100644 Runner/Wrappers/IDirectoryWrapper.cs
 rename Runner/{ => Wrappers}/IFileWrapper.cs (95%)

diff --git a/Runner.UnitTests/AssemblyScannerTests.cs b/Runner.UnitTests/AssemblyLoaderTests.cs
similarity index 74%
rename from Runner.UnitTests/AssemblyScannerTests.cs
rename to Runner.UnitTests/AssemblyLoaderTests.cs
index 1d3d903..a56893b 100644
--- a/Runner.UnitTests/AssemblyScannerTests.cs
+++ b/Runner.UnitTests/AssemblyLoaderTests.cs
@@ -19,22 +19,23 @@
 using System.IO;
 using System.Reflection;
 using Gauge.CSharp.Lib.Attribute;
+using Gauge.CSharp.Runner.Wrappers;
 using Moq;
 using NUnit.Framework;
 
 namespace Gauge.CSharp.Runner.UnitTests
 {
     [TestFixture]
-    public class AssemblyScannerTests
+    public class AssemblyLoaderTests
     {
         public class TestAssembly : Assembly { }
 
         [Step("Foo text")]
         public void DummyStepMethod() { }
 
-        private Mock<TestAssembly> mockAssembly;
+        private Mock<TestAssembly> _mockAssembly;
         private MethodInfo _stepMethod;
-        private AssemblyScanner _assemblyScanner;
+        private AssemblyLoader _assemblyLoader;
         private Mock<IAssemblyWrapper> _mockAssemblyWrapper;
 
         [SetUp]
@@ -48,15 +49,15 @@ public void Setup()
             _mockAssemblyWrapper = new Mock<IAssemblyWrapper>();
             var fileWrapper = new Mock<IFileWrapper>();
             _stepMethod = thisType.GetMethod("DummyStepMethod");
-            mockAssembly = new Mock<TestAssembly>();
-            mockAssembly.Setup(assembly => assembly.GetTypes()).Returns(new[] { thisType });
-            mockAssembly.Setup(assembly => assembly.GetType(thisType.FullName)).Returns(thisType);
-            mockAssembly.Setup(assembly => assembly.GetReferencedAssemblies()).Returns(new[] { new AssemblyName("Gauge.CSharp.Lib") });
+            _mockAssembly = new Mock<TestAssembly>();
+            _mockAssembly.Setup(assembly => assembly.GetTypes()).Returns(new[] { thisType });
+            _mockAssembly.Setup(assembly => assembly.GetType(thisType.FullName)).Returns(thisType);
+            _mockAssembly.Setup(assembly => assembly.GetReferencedAssemblies()).Returns(new[] { new AssemblyName("Gauge.CSharp.Lib") });
             fileWrapper.Setup(wrapper => wrapper.Exists(libPath)).Returns(true);
             _mockAssemblyWrapper.Setup(wrapper => wrapper.LoadFrom(libPath)).Returns(typeof(Step).Assembly).Verifiable();
-            _mockAssemblyWrapper.Setup(wrapper => wrapper.ReflectionOnlyLoadFrom(assemblyLocation)).Returns(mockAssembly.Object);
-            _mockAssemblyWrapper.Setup(wrapper => wrapper.LoadFrom(assemblyLocation)).Returns(mockAssembly.Object);
-            _assemblyScanner = new AssemblyScanner(_mockAssemblyWrapper.Object, fileWrapper.Object, new[] { assemblyLocation });
+            _mockAssemblyWrapper.Setup(wrapper => wrapper.ReflectionOnlyLoadFrom(assemblyLocation)).Returns(_mockAssembly.Object);
+            _mockAssemblyWrapper.Setup(wrapper => wrapper.LoadFrom(assemblyLocation)).Returns(_mockAssembly.Object);
+            _assemblyLoader = new AssemblyLoader(_mockAssemblyWrapper.Object, fileWrapper.Object, new[] { assemblyLocation });
         }
 
         [TearDown]
@@ -73,7 +74,7 @@ public void ShouldThrowExceptionWhenLibAssemblyNotFound()
             var mockAssemblyWrapper = new Mock<IAssemblyWrapper>();
             var fileWrapper = new Mock<IFileWrapper>();
 
-            Assert.Throws<FileNotFoundException>(() => new AssemblyScanner(mockAssemblyWrapper.Object, fileWrapper.Object, new[] { tmpLocation }));
+            Assert.Throws<FileNotFoundException>(() => new AssemblyLoader(mockAssemblyWrapper.Object, fileWrapper.Object, new[] { tmpLocation }));
         }
 
         [Test]
@@ -85,13 +86,13 @@ public void ShouldGetTargetAssembly()
         [Test]
         public void ShouldGetAssemblyReferencingGaugeLib()
         {
-            Assert.Contains(mockAssembly.Object, _assemblyScanner.AssembliesReferencingGaugeLib);
+            Assert.Contains(_mockAssembly.Object, _assemblyLoader.AssembliesReferencingGaugeLib);
         }
 
         [Test]
         public void ShouldGetMethodsForGaugeAttribute()
         {
-            Assert.Contains(_stepMethod, _assemblyScanner.GetMethods(typeof(Step)));
+            Assert.Contains(_stepMethod, _assemblyLoader.GetMethods(typeof(Step)));
         }
     }
 }
diff --git a/Runner.UnitTests/AssemblyLocaterTests.cs b/Runner.UnitTests/AssemblyLocaterTests.cs
new file mode 100644
index 0000000..5cbc55e
--- /dev/null
+++ b/Runner.UnitTests/AssemblyLocaterTests.cs
@@ -0,0 +1,137 @@
+// Copyright 2015 ThoughtWorks, Inc.
+//
+// This file is part of Gauge-CSharp.
+//
+// Gauge-CSharp is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Gauge-CSharp is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Gauge-CSharp.  If not, see <http://www.gnu.org/licenses/>.
+
+using System;
+using System.IO;
+using System.Linq;
+using Gauge.CSharp.Core;
+using Gauge.CSharp.Runner.Wrappers;
+using Moq;
+using NUnit.Framework;
+
+namespace Gauge.CSharp.Runner.UnitTests
+{
+    [TestFixture]
+    internal class AssemblyLocaterTests
+    {
+        private readonly Mock<IDirectoryWrapper> _mockDirectoryWrapper = new Mock<IDirectoryWrapper>();
+        private readonly Mock<IFileWrapper> _mockFileWrapper = new Mock<IFileWrapper>();
+
+        [SetUp]
+        public void Setup()
+        {
+            Environment.SetEnvironmentVariable("GAUGE_PROJECT_ROOT", Directory.GetCurrentDirectory());
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            Environment.SetEnvironmentVariable("GAUGE_ADDITIONAL_LIBS", null);
+            Environment.SetEnvironmentVariable("GAUGE_PROJECT_ROOT", null);
+        }
+
+        [Test]
+        public void ShouldGetAssembliesFromGaugeBin()
+        {
+            var expectedAssemblies = new[] {"fooAssemblyLocation", "barAssemblyLocation"};
+            _mockDirectoryWrapper.Setup(wrapper => wrapper.EnumerateFiles(Utils.GetGaugeBinDir(), "*.dll", SearchOption.TopDirectoryOnly))
+                .Returns(expectedAssemblies);
+            var assemblyLocater = new AssemblyLocater(_mockDirectoryWrapper.Object, _mockFileWrapper.Object);
+            
+            var assemblies = assemblyLocater.GetAllAssemblies();
+            
+            Assert.AreEqual(expectedAssemblies, assemblies);
+        }
+        
+        [Test]
+        public void ShouldGetAssembliesFromGaugeAdditionalLibsEnvVar()
+        {
+            Environment.SetEnvironmentVariable("GAUGE_ADDITIONAL_LIBS", "foo/");
+            var expectedAssemblies = new[] { "fooAssemblyLocation", "barAssemblyLocation" };
+            _mockDirectoryWrapper.Setup(wrapper => wrapper.Exists(Path.GetFullPath("foo/"))).Returns(true);
+            _mockDirectoryWrapper.Setup(wrapper => wrapper.EnumerateFiles(Utils.GetGaugeBinDir(), "*.dll", SearchOption.TopDirectoryOnly))
+                .Returns(Enumerable.Empty<string>());
+            _mockDirectoryWrapper.Setup(wrapper => wrapper.EnumerateFiles(Path.GetFullPath("foo/"), "*.dll", SearchOption.TopDirectoryOnly))
+                .Returns(expectedAssemblies);
+
+            var assemblyLocater = new AssemblyLocater(_mockDirectoryWrapper.Object, _mockFileWrapper.Object);
+
+            var assemblies = assemblyLocater.GetAllAssemblies();
+            Assert.AreEqual(expectedAssemblies, assemblies);
+        }
+
+        [Test]
+        public void ShouldAddAssembliyFromGaugeAdditionalLibFile()
+        {
+            Environment.SetEnvironmentVariable("GAUGE_ADDITIONAL_LIBS", "foo.dll");
+            var expectedAssemblies = new[] { Path.GetFullPath("foo.dll") };
+            _mockDirectoryWrapper.Setup(wrapper => wrapper.EnumerateFiles(Utils.GetGaugeBinDir(), "*.dll", SearchOption.TopDirectoryOnly))
+                .Returns(Enumerable.Empty<string>());
+            _mockFileWrapper.Setup(wrapper => wrapper.Exists(Path.GetFullPath("foo.dll"))).Returns(true);
+            var assemblyLocater = new AssemblyLocater(_mockDirectoryWrapper.Object, _mockFileWrapper.Object);
+
+            var assemblies = assemblyLocater.GetAllAssemblies();
+            Assert.AreEqual(expectedAssemblies, assemblies);
+        }
+
+        [Test]
+        public void ShouldAddAssembliesFromMultipleLocations()
+        {
+            Environment.SetEnvironmentVariable("GAUGE_ADDITIONAL_LIBS", "foo.dll, foo/");
+            var expectedAssemblies = new[] { Path.GetFullPath("foo.dll"), "fooAssemblyLocation", "barAssemblyLocation" };
+            _mockDirectoryWrapper.Setup(wrapper => wrapper.Exists(Path.GetFullPath("foo/"))).Returns(true);
+            _mockDirectoryWrapper.Setup(wrapper => wrapper.EnumerateFiles(Utils.GetGaugeBinDir(), "*.dll", SearchOption.TopDirectoryOnly))
+                .Returns(Enumerable.Empty<string>());
+            _mockDirectoryWrapper.Setup(wrapper => wrapper.EnumerateFiles(Path.GetFullPath("foo/"), "*.dll", SearchOption.TopDirectoryOnly))
+                .Returns(new []{"fooAssemblyLocation", "barAssemblyLocation"});
+            _mockFileWrapper.Setup(wrapper => wrapper.Exists(Path.GetFullPath("foo.dll"))).Returns(true);
+            var assemblyLocater = new AssemblyLocater(_mockDirectoryWrapper.Object, _mockFileWrapper.Object);
+
+            var assemblies = assemblyLocater.GetAllAssemblies();
+
+            Assert.AreEqual(expectedAssemblies, assemblies);
+        }
+
+        [Test]
+        public void ShoulNotdAddAssembliesFromInvalidDirectory()
+        {
+            Environment.SetEnvironmentVariable("GAUGE_ADDITIONAL_LIBS", "foo/");
+            _mockDirectoryWrapper.Setup(wrapper => wrapper.Exists(Path.GetFullPath("foo/"))).Returns(false);
+            _mockDirectoryWrapper.Setup(wrapper => wrapper.EnumerateFiles(Utils.GetGaugeBinDir(), "*.dll", SearchOption.TopDirectoryOnly))
+                .Returns(Enumerable.Empty<string>());
+
+            var assemblyLocater = new AssemblyLocater(_mockDirectoryWrapper.Object, _mockFileWrapper.Object);
+
+            var assemblies = assemblyLocater.GetAllAssemblies();
+            Assert.IsEmpty(assemblies);
+        }
+
+        [Test]
+        public void ShouldNotAddAssembliesFromInvalidFile()
+        {
+            Environment.SetEnvironmentVariable("GAUGE_ADDITIONAL_LIBS", "foo.dll");
+            _mockFileWrapper.Setup(wrapper => wrapper.Exists(Path.GetFullPath("foo.dll"))).Returns(false);
+            _mockDirectoryWrapper.Setup(wrapper => wrapper.EnumerateFiles(Utils.GetGaugeBinDir(), "*.dll", SearchOption.TopDirectoryOnly))
+                .Returns(Enumerable.Empty<string>());
+
+            var assemblyLocater = new AssemblyLocater(_mockDirectoryWrapper.Object, _mockFileWrapper.Object);
+
+            var assemblies = assemblyLocater.GetAllAssemblies();
+            Assert.IsEmpty(assemblies);
+        }
+    }
+}
diff --git a/Runner.UnitTests/Gauge.CSharp.Runner.UnitTests.csproj b/Runner.UnitTests/Gauge.CSharp.Runner.UnitTests.csproj
index 3c38784..7740dc0 100644
--- a/Runner.UnitTests/Gauge.CSharp.Runner.UnitTests.csproj
+++ b/Runner.UnitTests/Gauge.CSharp.Runner.UnitTests.csproj
@@ -75,7 +75,8 @@
     <Reference Include="System.Runtime" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="AssemblyScannerTests.cs" />
+    <Compile Include="AssemblyLocaterTests.cs" />
+    <Compile Include="AssemblyLoaderTests.cs" />
     <Compile Include="ClassInstanceManagerTests.cs" />
     <Compile Include="Converter\StringParamConverterTests.cs" />
     <Compile Include="Converter\TableParamConverterTests.cs" />
@@ -117,6 +118,9 @@
       <Name>Gauge.CSharp.Runner</Name>
     </ProjectReference>
   </ItemGroup>
+  <ItemGroup>
+    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
diff --git a/Runner.UnitTests/HookRegistryTests.cs b/Runner.UnitTests/HookRegistryTests.cs
index 1cc1f82..22f61c4 100644
--- a/Runner.UnitTests/HookRegistryTests.cs
+++ b/Runner.UnitTests/HookRegistryTests.cs
@@ -38,12 +38,12 @@ public class HookRegistryTests
 
         public ISandbox SandBox;
         private HookRegistry _hookRegistry;
-        private Mock<IAssemblyScanner> _mockAssemblyScanner;
+        private Mock<IAssemblyLoader> _mockAssemblyScanner;
 
         [SetUp]
         public void Setup()
         {
-            _mockAssemblyScanner = new Mock<IAssemblyScanner>();
+            _mockAssemblyScanner = new Mock<IAssemblyLoader>();
             _mockAssemblyScanner.Setup(scanner => scanner.GetTargetLibAssembly()).Returns(typeof (Step).Assembly);
             var types = new[]
             {
diff --git a/Runner/AssemblyScanner.cs b/Runner/AssemblyLoader.cs
similarity index 90%
rename from Runner/AssemblyScanner.cs
rename to Runner/AssemblyLoader.cs
index 0385294..eb1e6dc 100644
--- a/Runner/AssemblyScanner.cs
+++ b/Runner/AssemblyLoader.cs
@@ -24,33 +24,36 @@
 using System.Linq;
 using System.Reflection;
 using Gauge.CSharp.Core;
+using Gauge.CSharp.Runner.Wrappers;
 
 namespace Gauge.CSharp.Runner
 {
-    public class AssemblyScanner : IAssemblyScanner
+    public class AssemblyLoader : IAssemblyLoader
     {
         private static readonly string GaugeLibAssembleName = typeof(Step).Assembly.GetName().Name;
 
-        private static readonly Logger Logger = LogManager.GetLogger("AssemblyScanner");
+        private static readonly Logger Logger = LogManager.GetLogger("AssemblyLoader");
 
-        public List<Assembly> AssembliesReferencingGaugeLib = new List<Assembly>();
-        public List<Type> ScreengrabberTypes = new List<Type>();
+        public List<Assembly> AssembliesReferencingGaugeLib { get; private set; }
+        public List<Type> ScreengrabberTypes { get; private set; }
         private Assembly _targetLibAssembly;
         private readonly IAssemblyWrapper _assemblyWrapper;
         private readonly IFileWrapper _fileWrapper;
 
-        public AssemblyScanner(IAssemblyWrapper assemblyWrapper, IFileWrapper fileWrapper, IEnumerable<string> assemblyLocations)
+        public AssemblyLoader(IAssemblyWrapper assemblyWrapper, IFileWrapper fileWrapper, IEnumerable<string> assemblyLocations)
         {
             _assemblyWrapper = assemblyWrapper;
             _fileWrapper = fileWrapper;
             LoadTargetLibAssembly();
+            AssembliesReferencingGaugeLib= new List<Assembly>();
+            ScreengrabberTypes = new List<Type>();
             foreach (var location in assemblyLocations)
             {
                 ScanAndLoad(location);
             }
         }
 
-        public AssemblyScanner(IEnumerable<string> assemblyLocations)
+        public AssemblyLoader(IEnumerable<string> assemblyLocations)
             : this(new AssemblyWrapper(), new FileWrapper(), assemblyLocations)
         {
         }
diff --git a/Runner/AssemblyLocater.cs b/Runner/AssemblyLocater.cs
new file mode 100644
index 0000000..22837ad
--- /dev/null
+++ b/Runner/AssemblyLocater.cs
@@ -0,0 +1,80 @@
+// Copyright 2015 ThoughtWorks, Inc.
+//
+// This file is part of Gauge-CSharp.
+//
+// Gauge-CSharp is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Gauge-CSharp is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Gauge-CSharp.  If not, see <http://www.gnu.org/licenses/>.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using Gauge.CSharp.Core;
+using Gauge.CSharp.Runner.Wrappers;
+using NLog;
+
+namespace Gauge.CSharp.Runner
+{
+    public class AssemblyLocater : IAssemblyLocater
+    {
+        private static readonly Logger Logger = LogManager.GetCurrentClassLogger();
+        private readonly IDirectoryWrapper _directoryWrapper;
+        private readonly IFileWrapper _fileWrapper;
+
+        public AssemblyLocater(IDirectoryWrapper directoryWrapper, IFileWrapper fileWrapper)
+        {
+            _directoryWrapper = directoryWrapper;
+            _fileWrapper = fileWrapper;
+        }
+
+        public IEnumerable<string> GetAllAssemblies()
+        {
+            var assemblies = _directoryWrapper.EnumerateFiles(Utils.GetGaugeBinDir(), "*.dll", SearchOption.TopDirectoryOnly).ToList();
+            var gaugeAdditionalLibsPath = Environment.GetEnvironmentVariable("gauge_additional_libs");
+            if (string.IsNullOrEmpty(gaugeAdditionalLibsPath))
+                return assemblies;
+
+            var additionalLibPaths = gaugeAdditionalLibsPath.Split(',').Select(s => Path.GetFullPath(s.Trim()));
+            foreach (var libPath in additionalLibPaths)
+            {
+                if (Path.HasExtension(libPath))
+                {
+                    AddFile(libPath, assemblies);
+                    continue;
+                }
+                AddFilesFromDirectory(libPath, assemblies);
+            }
+            return assemblies;
+        }
+
+        private void AddFilesFromDirectory(string path, List<string> assemblies)
+        {
+            if (!_directoryWrapper.Exists(path))
+            {
+                Logger.Warn("Path does not exist: {0}", path);
+                return;
+            }
+            assemblies.AddRange(_directoryWrapper.EnumerateFiles(path, "*.dll", SearchOption.TopDirectoryOnly));
+        }
+
+        private void AddFile(string path, List<string> assemblies)
+        {
+            if (!_fileWrapper.Exists(path))
+            {
+                Logger.Warn("Path does not exist: {0}", path);
+                return;
+            }
+            assemblies.Add(path);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Runner/DefaultScreenGrabber.cs b/Runner/DefaultScreenGrabber.cs
index 0b2c214..0a9b9f2 100644
--- a/Runner/DefaultScreenGrabber.cs
+++ b/Runner/DefaultScreenGrabber.cs
@@ -1,3 +1,20 @@
+// Copyright 2015 ThoughtWorks, Inc.
+//
+// This file is part of Gauge-CSharp.
+//
+// Gauge-CSharp is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Gauge-CSharp is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Gauge-CSharp.  If not, see <http://www.gnu.org/licenses/>.
+
 using System.Drawing;
 using System.Drawing.Imaging;
 using System.IO;
diff --git a/Runner/Gauge.CSharp.Runner.csproj b/Runner/Gauge.CSharp.Runner.csproj
index 65231a9..351883f 100644
--- a/Runner/Gauge.CSharp.Runner.csproj
+++ b/Runner/Gauge.CSharp.Runner.csproj
@@ -109,8 +109,8 @@
     <Reference Include="System.Text.Encoding, Version=4.0.0.0" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="AssemblyScanner.cs" />
-    <Compile Include="AssemblyWrapper.cs" />
+    <Compile Include="AssemblyLocater.cs" />
+    <Compile Include="AssemblyLoader.cs" />
     <Compile Include="ClassInstanceManager.cs" />
     <Compile Include="Converters\IParamConverter.cs" />
     <Compile Include="DefaultScreenGrabber.cs" />
@@ -118,15 +118,13 @@
     <Compile Include="Exceptions\NotAValidGaugeProjectException.cs" />
     <Compile Include="ExecutionResult.cs" />
     <Compile Include="Extensions\AttributeExtensions.cs" />
-    <Compile Include="FileWrapper.cs" />
     <Compile Include="GaugeProjectBuilder.cs" />
     <Compile Include="HookMethod.cs" />
     <Compile Include="HookRegistry.cs">
       <SubType>Code</SubType>
     </Compile>
-    <Compile Include="IAssemblyScanner.cs" />
-    <Compile Include="IAssemblyWrapper.cs" />
-    <Compile Include="IFileWrapper.cs" />
+    <Compile Include="IAssemblyLoader.cs" />
+    <Compile Include="IAssemblyLocater.cs" />
     <Compile Include="IGaugeListener.cs" />
     <Compile Include="IGaugeProjectBuilder.cs" />
     <Compile Include="IHookRegistry.cs" />
@@ -180,6 +178,12 @@
     <Compile Include="Strategy\HooksStrategy.cs" />
     <Compile Include="Strategy\TaggedHooksFirstStrategy.cs" />
     <Compile Include="Strategy\UntaggedHooksFirstStrategy.cs" />
+    <Compile Include="Wrappers\AssemblyWrapper.cs" />
+    <Compile Include="Wrappers\DirectoryWrapper.cs" />
+    <Compile Include="Wrappers\FileWrapper.cs" />
+    <Compile Include="Wrappers\IAssemblyWrapper.cs" />
+    <Compile Include="Wrappers\IDirectoryWrapper.cs" />
+    <Compile Include="Wrappers\IFileWrapper.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="app.config" />
diff --git a/Runner/HookRegistry.cs b/Runner/HookRegistry.cs
index 636d18c..0f34c46 100644
--- a/Runner/HookRegistry.cs
+++ b/Runner/HookRegistry.cs
@@ -40,12 +40,12 @@ public class HookRegistry : IHookRegistry
             {typeof (AfterStep), new HashSet<HookMethod>()},
         };
 
-        public HookRegistry(IAssemblyScanner assemblyScanner)
+        public HookRegistry(IAssemblyLoader assemblyLoader)
         {
-            _targetLibAssembly = assemblyScanner.GetTargetLibAssembly();
+            _targetLibAssembly = assemblyLoader.GetTargetLibAssembly();
             foreach (var type in _hooks.Keys)
             {
-                AddHookOfType(type, assemblyScanner.GetMethods(type));
+                AddHookOfType(type, assemblyLoader.GetMethods(type));
             }
         }
 
diff --git a/Runner/IAssemblyScanner.cs b/Runner/IAssemblyLoader.cs
similarity index 86%
rename from Runner/IAssemblyScanner.cs
rename to Runner/IAssemblyLoader.cs
index 50c97f7..f2154c5 100644
--- a/Runner/IAssemblyScanner.cs
+++ b/Runner/IAssemblyLoader.cs
@@ -21,8 +21,10 @@
 
 namespace Gauge.CSharp.Runner
 {
-    public interface IAssemblyScanner
+    public interface IAssemblyLoader
     {
+        List<Assembly> AssembliesReferencingGaugeLib { get; }
+        List<Type> ScreengrabberTypes { get; }
         Assembly GetTargetLibAssembly();
         List<MethodInfo> GetMethods(Type annotationType);
     }
diff --git a/Runner/IAssemblyLocater.cs b/Runner/IAssemblyLocater.cs
new file mode 100644
index 0000000..8f92908
--- /dev/null
+++ b/Runner/IAssemblyLocater.cs
@@ -0,0 +1,26 @@
+// Copyright 2015 ThoughtWorks, Inc.
+//
+// This file is part of Gauge-CSharp.
+//
+// Gauge-CSharp is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Gauge-CSharp is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Gauge-CSharp.  If not, see <http://www.gnu.org/licenses/>.
+
+using System.Collections.Generic;
+
+namespace Gauge.CSharp.Runner
+{
+    public interface IAssemblyLocater
+    {
+        IEnumerable<string> GetAllAssemblies();
+    }
+}
\ No newline at end of file
diff --git a/Runner/Sandbox.cs b/Runner/Sandbox.cs
index 008a7d3..7d4aaea 100644
--- a/Runner/Sandbox.cs
+++ b/Runner/Sandbox.cs
@@ -21,9 +21,9 @@
 using System.IO;
 using System.Linq;
 using System.Reflection;
-using Gauge.CSharp.Core;
 using Gauge.CSharp.Lib;
 using Gauge.CSharp.Lib.Attribute;
+using Gauge.CSharp.Runner.Wrappers;
 using NLog;
 
 namespace Gauge.CSharp.Runner
@@ -31,7 +31,7 @@ namespace Gauge.CSharp.Runner
     [Serializable]
     public class Sandbox : MarshalByRefObject, ISandbox
     {
-        private readonly AssemblyScanner _assemblyScanner;
+        private readonly IAssemblyLoader _assemblyLoader;
 
         public Assembly TargetLibAssembly { get; private set; }
 
@@ -39,16 +39,20 @@ public class Sandbox : MarshalByRefObject, ISandbox
 
         private Type ScreenGrabberType { get; set; }
 
-        public Sandbox()
+        public Sandbox(IAssemblyLocater locater)
         {
             LogConfiguration.Initialize();
-            var assemblies = Directory.EnumerateFiles(Utils.GetGaugeBinDir(), "*.dll", SearchOption.TopDirectoryOnly);
-            _assemblyScanner = new AssemblyScanner(assemblies);
-            TargetLibAssembly = _assemblyScanner.GetTargetLibAssembly();
+            var assemblies = locater.GetAllAssemblies();
+            _assemblyLoader = new AssemblyLoader(assemblies);
+            TargetLibAssembly = _assemblyLoader.GetTargetLibAssembly();
             SetAppConfigIfExists();
             ScanCustomScreenGrabber();
         }
 
+        public Sandbox() : this(new AssemblyLocater(new DirectoryWrapper(), new FileWrapper()))
+        {
+        }
+
         [DebuggerStepperBoundary]
         [DebuggerHidden]
         public ExecutionResult ExecuteMethod(MethodInfo method, params object[] args)
@@ -72,12 +76,12 @@ public ExecutionResult ExecuteMethod(MethodInfo method, params object[] args)
 
         public IHookRegistry GetHookRegistry()
         {
-            return new HookRegistry(_assemblyScanner);
+            return new HookRegistry(_assemblyLoader);
         }
 
         public List<MethodInfo> GetStepMethods()
         {
-            return _assemblyScanner.GetMethods(typeof(Step));
+            return _assemblyLoader.GetMethods(typeof(Step));
         }
 
         public List<string> GetAllStepTexts()
@@ -127,7 +131,7 @@ public IEnumerable<string> GetAllPendingMessages()
 
         private void SetAppConfigIfExists()
         {            
-            var targetAssembly = _assemblyScanner.AssembliesReferencingGaugeLib.FirstOrDefault();
+            var targetAssembly = _assemblyLoader.AssembliesReferencingGaugeLib.FirstOrDefault();
             if (targetAssembly == null) return;
 
             var configFile = string.Format("{0}.config", targetAssembly.Location);
@@ -139,7 +143,7 @@ private void SetAppConfigIfExists()
 
         private void ScanCustomScreenGrabber()
         {
-            ScreenGrabberType = _assemblyScanner.ScreengrabberTypes.FirstOrDefault();
+            ScreenGrabberType = _assemblyLoader.ScreengrabberTypes.FirstOrDefault();
             if (ScreenGrabberType != null)
             {
                 Logger.Debug("Custom ScreenGrabber found : {0}", ScreenGrabberType.FullName);
diff --git a/Runner/AssemblyWrapper.cs b/Runner/Wrappers/AssemblyWrapper.cs
similarity index 96%
rename from Runner/AssemblyWrapper.cs
rename to Runner/Wrappers/AssemblyWrapper.cs
index f4c13fa..015d029 100644
--- a/Runner/AssemblyWrapper.cs
+++ b/Runner/Wrappers/AssemblyWrapper.cs
@@ -17,7 +17,7 @@
 
 using System.Reflection;
 
-namespace Gauge.CSharp.Runner
+namespace Gauge.CSharp.Runner.Wrappers
 {
     internal class AssemblyWrapper : IAssemblyWrapper
     {
diff --git a/Runner/Wrappers/DirectoryWrapper.cs b/Runner/Wrappers/DirectoryWrapper.cs
new file mode 100644
index 0000000..0c34c50
--- /dev/null
+++ b/Runner/Wrappers/DirectoryWrapper.cs
@@ -0,0 +1,35 @@
+// Copyright 2015 ThoughtWorks, Inc.
+//
+// This file is part of Gauge-CSharp.
+//
+// Gauge-CSharp is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Gauge-CSharp is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Gauge-CSharp.  If not, see <http://www.gnu.org/licenses/>.
+
+using System.Collections.Generic;
+using System.IO;
+
+namespace Gauge.CSharp.Runner.Wrappers
+{
+    public class DirectoryWrapper : IDirectoryWrapper
+    {
+        public IEnumerable<string> EnumerateFiles(string path, string pattern, SearchOption searchOption)
+        {
+            return Directory.EnumerateFiles(path, pattern, searchOption);
+        }
+
+        public bool Exists(string path)
+        {
+            return Directory.Exists(path);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Runner/FileWrapper.cs b/Runner/Wrappers/FileWrapper.cs
similarity index 95%
rename from Runner/FileWrapper.cs
rename to Runner/Wrappers/FileWrapper.cs
index 8f4d392..7f37b16 100644
--- a/Runner/FileWrapper.cs
+++ b/Runner/Wrappers/FileWrapper.cs
@@ -17,7 +17,7 @@
 
 using System.IO;
 
-namespace Gauge.CSharp.Runner
+namespace Gauge.CSharp.Runner.Wrappers
 {
     internal class FileWrapper : IFileWrapper
     {
diff --git a/Runner/IAssemblyWrapper.cs b/Runner/Wrappers/IAssemblyWrapper.cs
similarity index 95%
rename from Runner/IAssemblyWrapper.cs
rename to Runner/Wrappers/IAssemblyWrapper.cs
index f72b717..fd0a564 100644
--- a/Runner/IAssemblyWrapper.cs
+++ b/Runner/Wrappers/IAssemblyWrapper.cs
@@ -17,7 +17,7 @@
 
 using System.Reflection;
 
-namespace Gauge.CSharp.Runner
+namespace Gauge.CSharp.Runner.Wrappers
 {
     public interface IAssemblyWrapper
     {
diff --git a/Runner/Wrappers/IDirectoryWrapper.cs b/Runner/Wrappers/IDirectoryWrapper.cs
new file mode 100644
index 0000000..f4bca89
--- /dev/null
+++ b/Runner/Wrappers/IDirectoryWrapper.cs
@@ -0,0 +1,28 @@
+// Copyright 2015 ThoughtWorks, Inc.
+//
+// This file is part of Gauge-CSharp.
+//
+// Gauge-CSharp is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Gauge-CSharp is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Gauge-CSharp.  If not, see <http://www.gnu.org/licenses/>.
+
+using System.Collections.Generic;
+using System.IO;
+
+namespace Gauge.CSharp.Runner.Wrappers
+{
+    public interface IDirectoryWrapper
+    {
+        IEnumerable<string> EnumerateFiles(string path, string pattern, SearchOption searchOption);
+        bool Exists(string path);
+    }
+}
\ No newline at end of file
diff --git a/Runner/IFileWrapper.cs b/Runner/Wrappers/IFileWrapper.cs
similarity index 95%
rename from Runner/IFileWrapper.cs
rename to Runner/Wrappers/IFileWrapper.cs
index 7700a43..6f2e381 100644
--- a/Runner/IFileWrapper.cs
+++ b/Runner/Wrappers/IFileWrapper.cs
@@ -15,7 +15,7 @@
 // You should have received a copy of the GNU General Public License
 // along with Gauge-CSharp.  If not, see <http://www.gnu.org/licenses/>.
 
-namespace Gauge.CSharp.Runner
+namespace Gauge.CSharp.Runner.Wrappers
 {
     public interface IFileWrapper
     {