public SerializerTests()
        {
            this.bootstrapper = new ConfigurableBootstrapper(
                configuration => configuration.Modules(new Type[] { typeof(SerializerTestModule) }));

            this.browser = new Browser(bootstrapper);
        }

        public void GET_Given_An_Url_Shortened_Should_Return_Data_Of_The_Url()
        {
            //Arrange
            var url = new Model.Url("http://www.2dsolucoes.net");
            var repository = new StubUrlStorage(url);
            var bootstrapper = new ConfigurableBootstrapper(with =>
            {
                with.Dependency<IUrlStorage>(repository);
            });
            var browser = new Browser(bootstrapper);

            //Act
            var urlAPI = string.Format("/urls/{0}", url.Short);
            var response = browser.Get(urlAPI, ctx =>
            {
                ctx.HttpRequest();
            });

            dynamic result = response.Body.ToDynamic();

            //Assert
            Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
            Assert.That((string)result.Source, Is.EqualTo(url.Source));
            Assert.That((string)result.Short, Is.EqualTo(url.Short));
        }

        public BrowserFixture()
        {
            var bootstrapper =
                new ConfigurableBootstrapper();

            this.browser = new Browser(bootstrapper);
        }

        public void Should_return_main_page_with_valid_auth_cookie()
        {
            // Given
            var bootstrapper = new ConfigurableBootstrapper(with =>
            {
                with.Configure(env =>
                {
                    env.Diagnostics(
                        password: "password",
                        cryptographyConfiguration: this.cryptoConfig);
                });

                with.EnableAutoRegistration();
                with.Diagnostics<FakeDiagnostics>();
            });

            var browser = new Browser(bootstrapper);

            // When
            var result = browser.Get(DiagnosticsConfiguration.Default.Path + "/interactive/providers/", with =>
                {
                    with.Cookie(DiagsCookieName, this.GetSessionCookieValue("password"));
                });

            // Then should see our fake provider and not the default testing provider
            result.Body.AsString().ShouldContain("Fake testing provider");
            result.Body.AsString().ShouldNotContain("Testing Diagnostic Provider");
        }

        public async Task Should_return_info_page_if_password_empty()
        {
            // Given
            var bootstrapper = new ConfigurableBootstrapper(with =>
            {
                with.Configure(env =>
                {
                    env.Diagnostics(
                        enabled: true,
                        password: string.Empty,
                        cryptographyConfiguration: this.cryptoConfig);
                });

                with.EnableAutoRegistration();
                with.Diagnostics<DefaultDiagnostics>();
            });

            var browser = new Browser(bootstrapper);

            // When
            var result = await browser.Get(DiagnosticsConfiguration.Default.Path);

            // Then
            Assert.True(result.Body.AsString().Contains("Diagnostics Disabled"));
        }

        public void Should_fail_to_resolve_route_because_it_does_have_an_invalid_condition()
        {
            // Given
            var cache = new FakeRouteCache(with => {
                with.AddGetRoute("/invalidcondition", "modulekey", ctx => false);
            });

            var bootstrapper = new ConfigurableBootstrapper(with =>{
                with.RouteCache(cache);
            });

            var browser = new Browser(bootstrapper);

            // When
            var timer = new Stopwatch();
            timer.Start();

            for (var i = 0; i < numberOfTimesToResolveRoute; i++)
            {
                var result = browser.Get("/invalidcondition");
                result.StatusCode.ShouldEqual(HttpStatusCode.NotFound);
            }

            timer.Stop();

            // Then
            Debug.WriteLine(" took {0} to execute {1} times", timer.Elapsed, numberOfTimesToResolveRoute);
        }

		public void SetUp()
		{
			_fakeShortener = new FakeShortener();

			_bootstrapper = new ConfigurableBootstrapper(with => with.Dependency(_fakeShortener));
			_browser = new Browser(_bootstrapper);
		}

        public void SetUpBase()
        {
            this.ContentRepository = MockRepository.GenerateMock<IContentRepository>();
            this.ComponentLibrary = MockRepository.GenerateMock<IComponentSpecificationLibrary>();
            this.KolaConfigurationRegistry = MockRepository.GenerateMock<IKolaConfigurationRegistry>();
            this.DynamicSourceProvider = MockRepository.GenerateMock<IDynamicSourceProvider>();

            var bootstrapper = new ConfigurableBootstrapper(
                with =>
                    {
                        with.Dependency(this.ContentRepository);
                        with.Dependency(this.ComponentLibrary);
                        with.Dependency(this.KolaConfigurationRegistry);
                        with.Dependency(this.DynamicSourceProvider);
                        with.Dependency<TemplateResourceBuilder>();
                        with.Dependency<AmendmentDetailsResourceBuilder>();
                        with.Dependency<PathInstanceBuilder>();
                        with.Dependency<AmendmentsDetailsResourceBuilder>();
                        with.Dependency<UndoAmendmentDetailsResourceBuilder>();
                        with.Dependency<ComponentDetailsResourceBuilder>();
                        with.ResponseProcessor<TemplateJsonResultProcessor>();
                        with.ResponseProcessor<AmendmentDetailsJsonResultProcessor>();
                        with.ResponseProcessor<AmendmentsDetailsJsonResultProcessor>();
                        with.ResponseProcessor<UndoAmendmentDetailsJsonResultProcessor>();
                        with.ResponseProcessor<ComponentDetailsJsonResultProcessor>();
                        with.Dependency<TemplateService>();
                        with.Module<TemplateModule>();
                    });

            this.Browser = new Browser(bootstrapper);
        }

 public void FixtureSetup()
 {
     var formsAuthenticationConfiguration = new FormsAuthenticationConfiguration()
         {
             RedirectUrl = "~/login",
             UserMapper = new FakeUserMapper(new UserService())
         };
     var configuration = A.Fake<IRazorConfiguration>();
     var bootstrapper = new ConfigurableBootstrapper(config =>
         {
             config.Module<UsersModule>();
             config.Module<LoginModule>();
             config.ViewEngine(new RazorViewEngine(configuration));
         });
     var bootstrapper2 = new ConfigurableBootstrapper(config =>
         {
             config.Module<UsersModule>();
             config.Module<LoginModule>();
             config.ViewEngine(new RazorViewEngine(configuration));
             config.RequestStartup((x, pipelines, z) => FormsAuthentication.Enable(pipelines, formsAuthenticationConfiguration));
         });
     _notLoggedInBrowser = new Browser(bootstrapper);
     _loggedInBrowserResponse = new Browser(bootstrapper2).Post("/login", x =>
         {
             x.HttpRequest();
             x.FormValue("Username", "Chris1");
             x.FormValue("Password", "123");
         });
 }

        public AbsoluteUrlTests()
        {
            this.bootstrapper = new ConfigurableBootstrapper(
                    configuration => configuration.Modules(new Type[] { typeof(AbsoluteUrlTestModule) }));

            this.browser = new Browser(bootstrapper);
        }

        public void Should_find_usages_of_class()
        {
            const string editorText = 
@"public class myclass
{
    public void method() { }

    public void method_calling_method()
    {
        method();        
    }
}
";
            var solution = new FakeSolution();
            var project = new FakeProject();
            project.AddFile(editorText);
            solution.Projects.Add(project);

            var bootstrapper = new ConfigurableBootstrapper(c => c.Dependency<ISolution>(solution));
            var browser = new Browser(bootstrapper);

            var result = browser.Post("/findusages", with =>
            {
                with.HttpRequest();
                with.FormValue("FileName", "myfile");
                with.FormValue("Line", "3");
                with.FormValue("Column", "21");
                with.FormValue("Buffer", editorText);
            });

            var usages = result.Body.DeserializeJson<FindUsagesResponse>().Usages.ToArray();
            usages.Count().ShouldEqual(2);
            usages[0].Text.Trim().ShouldEqual("public void method() { }");
            usages[1].Text.Trim().ShouldEqual("method();");
        }

 public When_enabling_sessions()
 {
     _Bootstrapper = new ConfigurableBootstrapper(with =>
     {
         with.DisableAutoRegistration();
     });
     KeyValueStoreSessions.Enable(_Bootstrapper, A.Fake<IKeyValueStore>());
 }

 public void Nsub_WithBootstrapper_GetCalled()
 {
     this.task.GetValue().Returns("i did not fail");
     var bs = new ConfigurableBootstrapper(
         with => { with.Dependency(this.task).Module<IndexModule>(); });
     var browser = new Browser(bs);
     var actual = browser.Get("/");
     Assert.That(actual.Body.AsString(), Is.EqualTo("i did not fail"));
 }

        public PartialRenderingFixture()
        {
            var bootstrapper = new ConfigurableBootstrapper(with => {
                with.Module<PartialRenderingModule>();
            });

            this.browser =
                new Browser(bootstrapper);
        }

        public CaseSensitivityFixture()
        {
            var bootstrapper = new ConfigurableBootstrapper(with =>
            {
                with.Module<MainModule>();
            });

            this.browser = new Browser(bootstrapper);
        }

        public BrowserFixture()
        {
            var bootstrapper =
                new ConfigurableBootstrapper(config => config.Modules(typeof(EchoModule)));

            CookieBasedSessions.Enable(bootstrapper);

            this.browser = new Browser(bootstrapper);
        }

        public void Should_return_info_page_if_password_null()
        {
            var diagsConfig = new DiagnosticsConfiguration { Password = null, CryptographyConfiguration = this.cryptoConfig };
            var bootstrapper = new ConfigurableBootstrapper(b => b.DiagnosticsConfiguration(diagsConfig));
            var browser = new Browser(bootstrapper);

            var result = browser.Get("/_Nancy");

            Assert.True(result.Body.AsString().Contains("Diagnostics Disabled"));
        }

		public static Browser CreateBrowserWithCancellationToken(RouteRegistrar registrar, CancellationToken cancel)
		{
			var bootstrapper = new ConfigurableBootstrapper(with => with
				.Module(new AsyncCancelModule(registrar))
				.NancyEngine<NancyEngineWithAsyncCancellation>());

			var browser = new Browser(bootstrapper);
			((NancyEngineWithAsyncCancellation) bootstrapper.GetEngine()).CancellationToken = cancel;
			return browser;
		}

 public void FixtureSetup()
 {
     var configuration = A.Fake<IRazorConfiguration>();
     var bootstrapper = new ConfigurableBootstrapper(config =>
     {
         config.Module<TreesModule>();
         config.ViewEngine(new RazorViewEngine(configuration));
     });
     _browser = new Browser(bootstrapper);
 }

 public When_saving_a_session()
 {
     var boot = new ConfigurableBootstrapper(with =>
     {
         with.DisableAutoRegistration();
         with.Module<SessionTestModule>();
     });
     _Store = A.Fake<IKeyValueStore>();
     KeyValueStoreSessions.Enable(boot, _Store);
     _Browser = new Browser(boot);
 }