public StylesheetPipeline_Process_TestBase()
        {
            settings = new CassetteSettings();
            bundle = new StylesheetBundle("~");
            asset1 = new Mock<IAsset>();
            asset2 = new Mock<IAsset>();
            bundle.Assets.Add(asset1.Object);
            bundle.Assets.Add(asset2.Object);

            asset1.SetupGet(a => a.Path)
                  .Returns("~/asset1.css");
            asset1.Setup(a => a.OpenStream())
                  .Returns(() => "/* @reference \"asset2.css\"; */".AsStream());
            asset2.SetupGet(a => a.Path)
                  .Returns("~/asset2.css");
            asset2.Setup(a => a.OpenStream())
                  .Returns(() => "p { color: White; }".AsStream());
            asset1.SetupGet(a => a.References)
                  .Returns(new[] { new AssetReference(asset1.Object.Path, "~/asset2.css", -1, AssetReferenceType.SameBundle) });

            minifier = new MicrosoftStylesheetMinifier();
            urlGenerator = new Mock<IUrlGenerator>();
            container = new TinyIoCContainer();
            container.Register(minifier);
            container.Register(urlGenerator.Object);
            container.Register(settings);
        }

        public void GivenStylesheetCondition_WhenRender_ThenConditionalCommentWrapsLinks()
        {
            var bundle = new StylesheetBundle("~/test")
            {
                Condition = "CONDITION"
            };
            bundle.Assets.Add(new StubAsset());
            bundle.Assets.Add(new StubAsset());

            var urlGenerator = new Mock<IUrlGenerator>();
            var assetUrls = new Queue<string>(new[] { "asset1", "asset2" });
            urlGenerator.Setup(g => g.CreateAssetUrl(It.IsAny<IAsset>(), It.IsAny<bool>()))
                        .Returns(assetUrls.Dequeue);

            var renderer = new DebugStylesheetHtmlRenderer(urlGenerator.Object);
            var html = renderer.Render(bundle);

            html.ShouldEqual(
                "<!--[if CONDITION]>" + Environment.NewLine +
                "<link href=\"asset1\" type=\"text/css\" rel=\"stylesheet\"/>" +
                Environment.NewLine +
                "<link href=\"asset2\" type=\"text/css\" rel=\"stylesheet\"/>" + Environment.NewLine +
                "<![endif]-->"
            );
        }

 static StylesheetBundle StubStylesheetBundle(string path)
 {
     var bundle = new StylesheetBundle(path);
     var asset = new Mock<IAsset>();
     asset.SetupGet(a => a.Hash).Returns(new byte[] { 1, 2, 3 });
     bundle.Assets.Add(asset.Object);
     return bundle;
 }

 static StylesheetBundle StubStylesheetBundle(string path)
 {
     var bundle = new StylesheetBundle(path)
     {
         Hash = new byte[] { 1, 2, 3 }
     };
     return bundle;
 }

        Mock<IAsset> AddCssAsset(StylesheetBundle bundle, string css)
        {
            var asset = new Mock<IAsset>();
            bundle.Assets.Add(asset.Object);

            asset.SetupGet(a => a.Path).Returns("asset.css");
            asset.Setup(a => a.OpenStream()).Returns(() => css.AsStream());
            return asset;
        }

        public void GivenProductionMode_WhenProcess_ThenBundleRenderIsStylesheetHtmlRenderer()
        {
            var processor = new AssignStylesheetsRenderer();
            var settings = new CassetteSettings { IsDebuggingEnabled = false };
            var bundle = new StylesheetBundle("~/test");

            processor.Process(bundle, settings);

            bundle.Renderer.ShouldBeType<StylesheetHtmlRenderer>();
        }

        public void Configure(BundleCollection bundles, CassetteSettings settings)
        {
            var script = new ScriptBundle("cassette.web.jasmine");
            script.Assets.Add(new ResourceAsset("Cassette.Web.Jasmine.jasmine.js", GetType().Assembly));
            bundles.Add(script);

            var css = new StylesheetBundle("cassette.web.jasmine");
            css.Assets.Add(new ResourceAsset("Cassette.Web.Jasmine.jasmine.css", GetType().Assembly));
            bundles.Add(css);
        }

        public void GivenDebugMode_WhenProcess_ThenBundleRenderIsDebugStylesheetHtmlRenderer()
        {
            var settings = new CassetteSettings { IsDebuggingEnabled = true };
            var processor = new AssignStylesheetRenderer(Mock.Of<IUrlGenerator>(), settings);
            var bundle = new StylesheetBundle("~/test");

            processor.Process(bundle);

            bundle.Renderer.ShouldBeType<DebugStylesheetHtmlRenderer>();
        }

        public void ProcessCallsProcessor()
        {
            var bundle = new StylesheetBundle("~");
            var pipeline = new Mock<IBundlePipeline<StylesheetBundle>>();
            bundle.Pipeline = pipeline.Object;

            bundle.Process(new CassetteSettings());

            pipeline.Verify(p => p.Process(bundle));
        }

        public void ProcessCallsProcessor()
        {
            var bundle = new StylesheetBundle("~");
            var processor = new Mock<IBundleProcessor<StylesheetBundle>>();
            bundle.Processor = processor.Object;

            bundle.Process(new CassetteSettings());

            processor.Verify(p => p.Process(bundle, It.IsAny<CassetteSettings>()));
        }

 static StylesheetBundle CreateStylesheetBundle()
 {
     var bundle = new StylesheetBundle("~");
     var asset = new StubAsset(
         "~/asset.css",
         ".a { background-image:url(image-a.png);background-repeat:no-repeat;width:20px;height:20px }\n" +
         ".b { background-image:url(image-b.png);background-repeat:no-repeat;width:20px;height:20px }"
         );
     bundle.Assets.Add(asset);
     return bundle;
 }

        public void WhenProcessCssReferenceWithoutTrailingSemicolon_ThenAssetAddReferenceIsCalled()
        {
            var bundle = new StylesheetBundle("~");
            var css = "/* @reference \"test.css\" */";
            var asset = AddCssAsset(bundle, css);

            var processor = new ParseCssReferences();
            processor.Process(bundle, new CassetteSettings());

            asset.Verify(a => a.AddReference("test.css", 1));
        }

        public void WhenProcessSimpleCssReferenceWithSingleQuotes_ThenAssetAddReferenceIsCalled()
        {
            var bundle = new StylesheetBundle("~");
            var css = "/* @reference 'test.css'; */";
            var asset = AddCssAsset(bundle, css);

            var processor = new ParseCssReferences();
            processor.Process(bundle, new CassetteSettings());

            asset.Verify(a => a.AddReference("test.css", 1));
        }

        public void WhenProcessSimpleCssReference_ThenAssetAddReferenceIsCalled()
        {
            var bundle = new StylesheetBundle("~");
            var css = "/* @reference \"test.css\"; */";
            var asset = AddCssAsset(bundle, css);

            var processor = new ParseCssReferences();
            processor.Process(bundle);

            asset.Verify(a => a.AddReference("test.css", 1));
        }

        public void WhenProcessTwoCssReferencesInSameComment_ThenAssetAddReferenceIsCalledTwice()
        {
            var bundle = new StylesheetBundle("~");
            var css = "/* @reference \"test1.css\"; \n @reference \"test2.css\"; */";
            var asset = AddCssAsset(bundle, css);

            var processor = new ParseCssReferences();
            processor.Process(bundle);

            asset.Verify(a => a.AddReference("test1.css", 1));
            asset.Verify(a => a.AddReference("test2.css", 2));
        }

        public void GivenACompiler_WhenProcessCalled_ThenCompileAssetTransformerAddedToLessAsset()
        {
            var processor = new CompileLess(Mock.Of<ILessCompiler>(), new CassetteSettings());
            var bundle = new StylesheetBundle("~");
            var asset = new Mock<IAsset>();
            asset.SetupGet(a => a.Path).Returns("test.less");
            bundle.Assets.Add(asset.Object);

            processor.Process(bundle);

            asset.Verify(a => a.AddAssetTransformer(It.Is<IAssetTransformer>(at => at is CompileAsset)));
        }

        public void WhenModifiedPipelineProcessesBundle_ThenLessAssetHasCompileAssetTransformAdded()
        {
            var asset = new Mock<IAsset>();
            asset.SetupGet(a => a.Path).Returns("~/file.less");
            asset.Setup(a => a.OpenStream()).Returns(Stream.Null);
            var bundle = new StylesheetBundle("~");
            bundle.Assets.Add(asset.Object);

            modifiedPipeline.Process(bundle);

            asset.Verify(a => a.AddAssetTransformer(It.Is<IAssetTransformer>(t => t is CompileAsset)));
        }

        public SpritingIntegrationTest()
        {
            container = CreateContainer();
            cache = new TempDirectory();
            InitDirectories();

            bundle = CreateStylesheetBundle();

            // SpriteImages expects image URLs to be expanded into absolute Cassette file URLs.
            ExpandUrls(bundle);
            SpriteImages(bundle);
        }

        public StylesheetBundleSerializer_Tests()
        {
            bundle = new StylesheetBundle("~")
            {
                Hash = new byte[0],
                Media = "MEDIA",
                Condition = "CONDITION",
                Renderer = new StylesheetHtmlRenderer(Mock.Of<IUrlGenerator>())
            };

            WriteToElement();
        }

        public StylesheetBundleSerializer_Tests()
        {
            bundle = new StylesheetBundle("~")
            {
                Hash = new byte[0],
                Media = "MEDIA",
                Condition = "CONDITION",
                Renderer = new ConstantHtmlRenderer<StylesheetBundle>("", new VirtualDirectoryPrepender("/"))
            };

            WriteToElement();
        }