web_resource_bundler 0.0.20 → 0.0.21

data/lib/web_resource_bundler.rb

@@ -5,173 +5,148 @@ require 'content_management/css_url_rewriter'
 require 'content_management/resource_file'
 
 require 'file_manager'
-require 'settings_manager'
+require 'settings'
 require 'logger'
 require 'filters'
 require 'exceptions'
 require 'rails_app_helpers'
 require 'yaml'
-require 'singleton'
 require 'digest/md5'
+require 'uri'
 
 module WebResourceBundler
   class Bundler
-    include Singleton
 
-    attr_reader :settings, :settings_correct, :filters, :logger
+    class << self
 
-    def initialize
-      @filters = {} 
-      @settings = nil
-      @file_manager = FileManager.new('','') 
-      @parser = BlockParser.new
-      @logger = nil 
-      @settings_correct = false
-    end
+      attr_reader :filters, :logger
 
-    #this method should called in initializer
-    def setup(rails_root, rails_env)
-      @settings = SettingsManager.create_settings(rails_root, rails_env)
-      @settings_correct = SettingsManager.settings_correct?(@settings)
-      if @settings_correct
-        @logger = create_logger(@settings[:log_path]) unless @logger
-        @file_manager.resource_dir, @file_manager.cache_dir = @settings[:resource_dir], @settings[:cache_dir]
-        set_filters(@settings, @file_manager) 
+      #this method should called in initializer
+      def setup(rails_root, rails_env)
+        settings = Settings.create_settings(rails_root, rails_env)
+        return false unless Settings.correct? 
+        @logger       = create_logger(settings[:log_path]) unless @logger
+        @file_manager = FileManager.new(settings)
+        @filters      = set_filters({}, @file_manager)
       end
-    end
 
-    #this method should be used to turn on\off filters
-    #on particular request
-    def set_settings(settings)
-      @settings.merge!(settings)
-      @settings_correct = SettingsManager.settings_correct?(@settings)
-      set_filters(@settings, @file_manager)
-    end
+      #this method should be used to turn on\off filters
+      #on particular specific request
+      def set_settings(settings)
+        begin
+          return false unless Settings.correct?(settings)
+          Settings.set(settings)
+          set_filters(@filters, @file_manager)
+          @file_manager.set_settings(settings) 
+          true
+        rescue Exception => e
+          @logger.error("Error occured while trying to change settings")
+          false
+        end
+      end
 
-    #main method to process html text block
-    def process(block, domain, protocol)
-      if @settings_correct
+      #main method to process html text block
+      #filters settings changed with request specific data
+      #html block parsed, and resulted bundle file names calculated
+      #we don't want to read files from disk on each request
+      #if bundle is not up to date block_data populated with files content
+      #all filters applied and resulted block_data returnd
+      #all exceptions resqued and logged so that no exceptions are raised in rails app
+      def process(block, domain, protocol)
+        return nil unless Settings.correct? 
         begin
-          filters = filters_array
-          #passing current request domain and protocol to each filter
-          filters.each do |filter|
-            SettingsManager.set_request_specific_settings!(filter.settings, domain, protocol)
-          end
-          #parsing html text block, creating BlockData instance
-          block_data = @parser.parse(block)
-          #if filters set and no bundle files exists we should process block data
-          unless filters.empty? or bundle_upto_date?(block_data)
-            #reading files content and populating block_data
+          block_data = BlockParser.parse(block)
+          filters    = filters_array(@filters)
+          set_filters_request_specific_data!(filters, domain, protocol)
+          if filters.any? && !bundle_upto_date?(block_data, @filters)
             read_resources!(block_data)
-            #applying filters to block_data
             block_data.apply_filters(filters)
-            #writing resulted files with filtered content on disk
             write_files_on_disk(block_data)
             @logger.info("files written on disk")
             return block_data
           end
-          #bundle up to date, returning existing block with modified file names 
           block_data.apply_filters(filters)
-          return block_data
-        rescue Exceptions::WebResourceBundlerError => e
-          @logger.error(e.to_s)
-          return nil
+          block_data
         rescue Exception => e
-          @logger.error(e.backtrace.join("\n") + "Unknown error occured: " + e.to_s)
-          return nil
+          @logger.error("Error occured: " + e.to_s)
+          nil
         end
       end
-    end
 
-    private
+      private
 
-    #giving filters array in right sequence (bundle filter should be first)
-    def filters_array
-      filters = []
-      %w{bundle_filter base64_filter cdn_filter}.each do |key|
-        filters << @filters[key.to_sym] if @settings[key.to_sym][:use] and @filters[key.to_sym] 
+      def set_filters_request_specific_data!(filters, domain, protocol)
+        filters.each do |filter|
+          Settings.set_request_specific_data!(filter.settings, domain, protocol)
+        end
       end
-      filters
-    end
 
-    #creates filters or change their settings
-    def set_filters(settings, file_manager)
-      filters_data = {
-        :bundle_filter => 'BundleFilter',
-        :base64_filter => 'ImageEncodeFilter',
-        :cdn_filter => 'CdnFilter'
-      }
-      filters_data.each_pair do |key, filter_class| 
-        #if filter settings are present and filter turned on
-        if settings[key] and settings[key][:use] 
-          filter_settings = SettingsManager.send("#{key}_settings", settings) 
-          if @filters[key] 
-            @filters[key].set_settings(filter_settings)
-          else
-            #creating filter instance with settings
-            @filters[key] = eval("Filters::" + filter_class + "::Filter").new(filter_settings, file_manager)
-          end
+      #giving filters array in right sequence (bundle filter should be first)
+      def filters_array(filters_hash)
+        filters = []
+        [:bundle_filter, :base64_filter, :cdn_filter].each do |name|
+          filters << filters_hash[name] if Settings.filter_used?(name) && filters_hash[name]
         end
+        filters
       end
-      @filters
-    end
 
-    def create_logger(log_path)
-      begin
-        log_dir = File.dirname(log_path)
-        #we should create log dir in rails root if it doesn't exist
-        Dir.mkdir(log_dir) unless File.exist?(log_dir)
-        file = File.open(log_path, File::WRONLY | File::APPEND | File::CREAT)
-        logger = Logger.new(file)
-      rescue Exception => e
-        raise WebResourceBundler::Exceptions::LogCreationError.new(log_path, e.to_s) 
+      #creates filters or change existing filter settings
+      def set_filters(filters, file_manager)
+        Filters::FILTER_NAMES.each_pair do |name, klass| 
+          if Settings.filter_used?(name) 
+            filter_settings = Settings.filter_settings(name) 
+            filters[name] ? filters[name].set_settings(filter_settings) : filters[name] = klass::Filter.new(filter_settings, file_manager)
+          end
+        end
+        filters
       end
-      logger
-    end
 
-    #checks if resulted files exist for current @filters and block data
-    def bundle_upto_date?(block_data)
-      #we don't want to change original parsed block data
-      #so just making a clone, using overriden clone method in BlockData
-      block_data_copy = block_data.clone
-      #modifying clone to obtain resulted files
-      #apply_filters will just compute resulted file paths
-      #because block_data isn't populated with files content yet
-      block_data_copy.apply_filters(filters_array)
-      #cheking if resulted files exist on disk in cache folder
-      block_data_copy.all_files.each do |file|
-        return false unless File.exist?(File.join(@settings[:resource_dir], file.path))
+      #creates logger object with new log file in rails_app/log
+      #or appends to existing log file, log dir also created
+      #all exception catched
+      def create_logger(log_path)
+        begin
+          log_dir = File.dirname(log_path)
+          Dir.mkdir(log_dir) unless File.exist?(log_dir)
+          file   = File.open(log_path, File::WRONLY | File::APPEND | File::CREAT)
+          logger = Logger.new(file)
+        rescue Exception => e
+          raise WebResourceBundler::Exceptions::LogCreationError.new(log_path, e.to_s) 
+        end
+        logger
       end
-      true
-    end
 
-    #reads block data resource files content from disk and populating block_data
-    def read_resources!(block_data)
-      #iterating through each resource files
-      block_data.files.each do |file|
-        content = @file_manager.get_content(file.path)
-        #rewriting url to absolute if content is css
-        WebResourceBundler::CssUrlRewriter.rewrite_content_urls!(file.path, content) if file.types.first[:ext] == 'css'  
-        file.content = content
-      end
-      #making the same for each child blocks, recursively
-      block_data.child_blocks.each do |block|
-        read_resources!(block)
+      #creates a clone of block_data to calculate resulted file names
+      #all filters applied to block_data
+      #if resulted bundle files exists - we considering bundle up to date
+      def bundle_upto_date?(block_data, filters)
+        block_data_copy = block_data.clone
+        filters         = filters_array(filters)
+        block_data_copy.apply_filters(filters)
+        block_data_copy.all_files.each do |file|
+          return false unless File.exist?(File.join(Settings.settings[:resource_dir], file.path))
+        end
+        true
       end
-    end
 
-    #recursive method to write all resulted files on disk
-    def write_files_on_disk(block_data)
-      @file_manager.create_cache_dir
-      block_data.files.each do |file|
-        File.open(File.join(@settings[:resource_dir], file.path), "w") do |f|
-          f.print(file.content)
+      #block_data and its childs (whole tree) populated with files content recursively
+      #relative url in css files rewritten to absolute
+      def read_resources!(block_data)
+        block_data.files.each do |file|
+          content = @file_manager.get_content(file.path)
+          WebResourceBundler::CssUrlRewriter.rewrite_content_urls!(file.path, content) if file.type[:ext] == 'css'  
+          file.content = content
         end
+        block_data.child_blocks.each { |block| read_resources!(block) }
       end
-      block_data.child_blocks.each do |block|
-        write_files_on_disk(block)
+
+      #recursive method to write all resulted files on disk
+      def write_files_on_disk(block_data)
+        @file_manager.create_cache_dir
+        block_data.files.each        { |file| @file_manager.write_file(file.path, file.content) } 
+        block_data.child_blocks.each { |block| write_files_on_disk(block)                       } 
       end
-    end
 
+    end
   end
 end

data/spec/sample_block_helper.rb

@@ -29,8 +29,8 @@ class SampleBlockHelper
     block
   end
 
-  def construct_resource_file(file, content, *types)
-    resource_file = WebResourceBundler::ResourceFile.new(file, '', types)
+  def construct_resource_file(file, content, type)
+    resource_file = WebResourceBundler::ResourceFile.new(file, '', type)
     if content
       resource_file.content = content
     else
@@ -55,7 +55,7 @@ class SampleBlockHelper
   def sample_block_data
     data = BlockData.new
     @styles[0..(@styles.size / 2 - 1)].each do |file|
-      data.files << construct_resource_file(file, nil, ResourceFileType::CSS, ResourceFileType::IE_CSS)
+      data.files << construct_resource_file(file, nil, ResourceFileType::CSS)
     end
     @scripts[0..(@scripts.size / 2 - 1)].each do |file|
       data.files << construct_resource_file(file, nil, ResourceFileType::JS)

data/spec/web_resource_bundler/content_management/block_data_spec.rb

@@ -1,30 +1,75 @@
 require File.expand_path(File.join(File.dirname(__FILE__), "../../spec_helper"))
 describe WebResourceBundler::BlockData do
+
+  before(:each) do
+    @block_data = @sample_block_helper.sample_block_data
+  end
+
+  describe "#styles" do
+    it "should return all files with 'css' extension" do
+      @block_data.styles.each do |file|
+        File.basename(file.path).split('.')[-1].should == 'css'
+      end
+    end
+  end
+
+  describe "#scripts" do
+    it "should return all files with 'js' extension" do
+      @block_data.scripts.each do |file|
+        File.basename(file.path).split('.')[-1].should == 'js'
+      end
+    end
+  end
+
+  describe "#mhtml_styles" do
+    it "should return all files with 'js' extension" do
+      @block_data.files = @block_data.files[0..2]
+      @block_data.files.first.type = WebResourceBundler::ResourceFileType::MHTML_CSS
+      @block_data.files[1].type = WebResourceBundler::ResourceFileType::CSS
+      @block_data.files.last.type = WebResourceBundler::ResourceFileType::MHTML
+      @block_data.mhtml_styles.size.should == 3
+    end
+  end
+
+  describe "#base64_styles" do
+    it "should return all files with 'js' extension" do
+      @block_data.files = @block_data.files[0..1]
+      @block_data.files.first.type = WebResourceBundler::ResourceFileType::BASE64_CSS
+      @block_data.files.last.type = WebResourceBundler::ResourceFileType::CSS
+      @block_data.base64_styles.size.should == 2
+    end
+  end
+
+  describe "#scripts" do
+    it "should return all files with 'js' extension" do
+      @block_data.scripts.each do |file|
+        File.basename(file.path).split('.')[-1].should == 'js'
+      end
+    end
+  end
+
   describe "#apply_filter" do
     it "applies filter to block_data, its childs, and theirs childs etc." do
       filter = mock("filter")
-      block_data = @sample_block_helper.sample_block_data
-      filter.should_receive(:apply!).with(block_data)
-      filter.should_receive(:apply!).with(block_data.child_blocks.first)
+      filter.should_receive(:apply!).with(@block_data)
+      filter.should_receive(:apply!).with(@block_data.child_blocks.first)
       filters = [filter]
-      block_data.apply_filters(filters)
+      @block_data.apply_filters(filters)
     end
   end
 
   describe "#all_childs" do
     it "creates array of block data and all its childs recursively" do
-      block_data = @sample_block_helper.sample_block_data
-      BlockData.all_childs(block_data).size.should == 2
+      BlockData.all_childs(@block_data).size.should == 2
     end
   end
 
   describe "#clone" do
     it "creates deep clone of block data" do
-      block_data = @sample_block_helper.sample_block_data
-      clon = block_data.clone
-      block_data.object_id.should_not == clon.object_id
-      ((block_data.files.map { |f| f.object_id })& clon.files.map {|f| f.object_id}).should be_empty
-      child = block_data.child_blocks[0]
+      clon = @block_data.clone
+      @block_data.object_id.should_not == clon.object_id
+      ((@block_data.files.map { |f| f.object_id })& clon.files.map {|f| f.object_id}).should be_empty
+      child = @block_data.child_blocks[0]
       child_copy = clon.child_blocks[0]
       child.object_id.should_not == child_copy.object_id 
       ((child.files.map { |f| f.object_id }) & child_copy.files.map {|f| f.object_id}).should be_empty

data/spec/web_resource_bundler/content_management/block_parser_spec.rb

@@ -4,8 +4,8 @@ module WebResourceBundler
 
     before(:each) do
       @settings = settings
-      @file_manager = FileManager.new(@settings[:resource_dir], @settings[:cache_dir])
-      @block_parser = BlockParser.new
+      @file_manager = FileManager.new(@settings)
+      @block_parser = BlockParser
     end
 
     #conditional comment spec
@@ -31,17 +31,17 @@ module WebResourceBundler
         block += @sample_block_helper.sample_inline_block
         block += @sample_block_helper.construct_links_block(styles, scripts)
         block += @sample_block_helper.sample_inline_block
-        @block_parser.remove_links(block).should == @sample_block_helper.sample_inline_block + @sample_block_helper.sample_inline_block
+        @block_parser.send(:remove_links, block).should == @sample_block_helper.sample_inline_block + @sample_block_helper.sample_inline_block
       end
 
       it "doesn't delete links to non js or css resource, like favicon for example" do
         text = "<link href='1.css' /><link rel='shortcut icon' href='/favicon.ico' />"
-        @block_parser.remove_links(text).should == "<link rel='shortcut icon' href='/favicon.ico' />"
+        @block_parser.send(:remove_links, text).should == "<link rel='shortcut icon' href='/favicon.ico' />"
       end
 
       it "doesn't touch remote resources" do
         text = "<link href='http://google.com/1.css' type='text/css' rel='stylesheet' />"
-        @block_parser.remove_links(text).include?(text).should be_true
+        @block_parser.send(:remove_links, text).include?(text).should be_true
       end
     end
 
@@ -51,8 +51,6 @@ module WebResourceBundler
         @block_parser.parse("").is_a?(BlockData).should be_true
       end
 
-      
-
       it "returns empty BlockData when block is empty" do
         data = @block_parser.parse("")
         data.files.should be_empty
@@ -76,7 +74,7 @@ module WebResourceBundler
     describe "#find_files" do
     
       it "returns array of css and js files linked in block" do
-        result = @block_parser.find_files(@sample_block_helper.construct_links_block(styles, scripts))
+        result = @block_parser.send(:find_files, @sample_block_helper.construct_links_block(styles, scripts))
         files = styles + scripts
         result.each do |f|
           files.include?(f.path).should be_true
@@ -85,17 +83,33 @@ module WebResourceBundler
 
       it "recognize only css and js files" do
         block = "<link href='/rss.atom' /> <link href='valid.css' />"
-        result = @block_parser.find_files(block)
+        result = @block_parser.send(:find_files, block)
         result.first.path.should == 'valid.css'
       end
 
       it "recognize files only on disk, not full urls" do
         block = "<link href='http://glogle.com/web.css' /> <link href='valid.css' />"
-        result = @block_parser.find_files(block)
+        result = @block_parser.send(:find_files, block)
         result.first.path.should == 'valid.css'
       end
 
     end
 
+    describe "#create_resource_file" do
+      it "returns nil if attributes not src or href" do
+        @block_parser.send(:create_resource_file, 'invalid', '1.jpg').should == nil
+      end
+      it "returns nil if file isn't css or js" do
+        @block_parser.send(:create_resource_file, 'href', '1.cssI').should == nil
+        @block_parser.send(:create_resource_file, 'src', '1.jsI').should == nil
+      end
+      it "returns correct ResourceFile if conditions met" do
+        @block_parser.send(:create_resource_file, 'href', '1.css').path.should == '1.css' 
+        @block_parser.send(:create_resource_file, 'src', '1.js').path.should == '1.js'
+      end
+    end
+
   end
+
+  
 end

data/spec/web_resource_bundler/content_management/resource_file_spec.rb

@@ -5,31 +5,23 @@ describe WebResourceBundler::ResourceFile do
       f = WebResourceBundler::ResourceFile.new_css_file('a', 'b')
       f.path.should == 'a'
       f.content.should == 'b'
-      f.types.first.should == WebResourceBundler::ResourceFileType::CSS
+      f.type.should == WebResourceBundler::ResourceFileType::CSS
     end
   end
   describe "#new_js_file" do
-    it "creates new resource file of css type" do
+    it "creates new resource file of js type" do
       f = WebResourceBundler::ResourceFile.new_js_file('a', 'b')
       f.path.should == 'a'
       f.content.should == 'b'
-      f.types.first.should == WebResourceBundler::ResourceFileType::JS
-    end
-  end
-  describe "#new_mhtml_file" do
-    it "creates new resource file of mhtml type" do
-      f = WebResourceBundler::ResourceFile.new_mhtml_file('a', 'b')
-      f.path.should == 'a'
-      f.content.should == 'b'
-      f.types.first.should == WebResourceBundler::ResourceFileType::MHTML
+      f.type.should == WebResourceBundler::ResourceFileType::JS
     end
   end
-  describe "#new_style_file" do
-    it "creates new resource file of CSS and IE_CSS type" do
-      f = WebResourceBundler::ResourceFile.new_style_file('a', 'b')
+  describe "#new_mhtml_css_file" do
+    it "creates new resource file of mhtml css type" do
+      f = WebResourceBundler::ResourceFile.new_mhtml_css_file('a', 'b')
       f.path.should == 'a'
       f.content.should == 'b'
-      f.types.should == [WebResourceBundler::ResourceFileType::CSS, WebResourceBundler::ResourceFileType::IE_CSS]
+      f.type.should == WebResourceBundler::ResourceFileType::MHTML_CSS
     end
   end
   describe "#clone" do

data/spec/web_resource_bundler/file_manager_spec.rb

@@ -1,8 +1,5 @@
 require File.expand_path(File.join(File.dirname(__FILE__), "../spec_helper"))
 describe WebResourceBundler::FileManager do
-  before(:each) do
-    @settings = settings
-  end
 
   def create_stub_file(name)
     File.open(File.join(@settings[:resource_dir], name), "w") do |file|
@@ -11,12 +8,13 @@ describe WebResourceBundler::FileManager do
   end
 
   before(:each) do
+    @settings = settings
     temp_dir = File.join(@settings[:resource_dir], 'temp')
     Dir.mkdir(temp_dir) unless File.exist?(temp_dir)
     @bundle_url = 'temp/bundle.dat'
     @bundle_path = File.join(@settings[:resource_dir], @bundle_url)
     create_stub_file(@bundle_url)
-    @manager = FileManager.new(@settings[:resource_dir], @settings[:cache_dir])
+    @manager = FileManager.new(@settings)
   end
 
   after(:each) do
@@ -32,6 +30,16 @@ describe WebResourceBundler::FileManager do
     end
   end
 
+  describe "#set_settings" do
+    it "should set new settings in file manager" do
+      @manager.resource_dir.should == @settings[:resource_dir]
+      @manager.cache_dir.should == @settings[:cache_dir]
+      @manager.set_settings({:resource_dir => 'A', :cache_dir => 'B'})
+      @manager.resource_dir.should == 'A'
+      @manager.cache_dir.should == 'B' 
+    end
+  end
+
   describe "#get_content" do
     it "reads file and returns its content" do
       @manager.get_content(@bundle_url).should == 'hi there'

data/spec/web_resource_bundler/filters/bundle_filter/filter_spec.rb

@@ -4,11 +4,11 @@ describe WebResourceBundler::Filters::BundleFilter::Filter do
     clean_cache_dir
     @settings = settings
     @bundle_settings = bundle_settings
-    @filter = Filters::BundleFilter::Filter.new(@bundle_settings, FileManager.new(@settings[:resource_dir], @settings[:cache_dir]))
+    @filter = Filters::BundleFilter::Filter.new(@bundle_settings, FileManager.new(@settings))
     @block_data = @sample_block_helper.sample_block_data
     css_type = ResourceFileType::CSS
     js_type = ResourceFileType::JS
-    items = [@block_data.styles.map {|f| f.path}.sort] + [@bundle_settings[:protocol], @bundle_settings[:domain]]
+    items = [@block_data.files.select{|f| f.type[:ext] == 'css'}.map {|f| f.path}.sort] + [@bundle_settings[:protocol], @bundle_settings[:domain]]
     items += @bundle_settings[:md5_additional_data] if @bundle_settings[:md5_additional_data]
     @css_md5_value = Digest::MD5.hexdigest(items.flatten.join('|'))
     @css_bundle_file = File.join(@settings[:cache_dir], [css_type[:name] + '_' + @css_md5_value, 'en', css_type[:ext]].join('.'))
@@ -21,20 +21,20 @@ describe WebResourceBundler::Filters::BundleFilter::Filter do
   describe "#apply" do
     it "bundles each block_data resources in single file" do
       @filter.apply!(@block_data)
-      @block_data.styles.first.path.should == @css_bundle_file
+      @block_data.files.select{|f| f.type[:ext] == 'css'}.first.path.should == @css_bundle_file
       @block_data.scripts.first.path.should == @js_bundle_file
     end
   end
 
   describe "#get_md5" do
     it "returns md5 from sorted filepaths and another additional data" do
-      @filter.get_md5(@block_data.styles).should == @css_md5_value
+      @filter.send(:get_md5, @block_data.files.select{|f| f.type[:ext] == 'css'}).should == @css_md5_value
     end
   end
 
   describe "#bundle_filepath" do
     it "returns filename of bundle constructed from passed files" do
-      @filter.bundle_filepath(WebResourceBundler::ResourceFileType::CSS, @block_data.styles).should == @css_bundle_file 
+      @filter.send(:bundle_filepath, WebResourceBundler::ResourceFileType::CSS, @block_data.files.select{|f| f.type[:ext] == 'css'}).should == @css_bundle_file 
     end
   end
 

data/spec/web_resource_bundler/filters/bundle_filter/resource_packager_spec.rb

@@ -3,7 +3,7 @@ require 'digest/md5'
 describe WebResourceBundler::Filters::BundleFilter::ResourcePackager do
   before(:each) do
     @settings = settings
-    file_manager = FileManager.new(@settings[:resource_dir], @settings[:cache_dir])
+    file_manager = FileManager.new(@settings)
     @file_packager = Filters::BundleFilter::ResourcePackager.new(@settings, file_manager)
     @file_paths = styles.map do |url|
       File.join(@settings[:resource_dir], url)
@@ -13,12 +13,25 @@ describe WebResourceBundler::Filters::BundleFilter::ResourcePackager do
   describe "#extract_imported_files!" do
     it "returns array of imported css files" do
       content = "@import 'import/first.css';\n@import 'import/second.css';"
-      imported_files = @file_packager.extract_imported_files!(content, 'styles/base.css')
+      imported_files = @file_packager.send(:extract_imported_files!, content, 'styles/base.css')
       content.should == "\n"
       imported_files.should == ['styles/import/first.css', 'styles/import/second.css']
     end
   end
 
+  describe "#build_imported_files" do
+    it "should return css resource files" do
+      files = @file_packager.send(:build_imported_files, styles)
+      files.each do |file|
+        styles.include?(file.path).should be_true
+      end
+    end
+    it "should return empty array if paths are not css" do
+      files = @file_packager.send(:build_imported_files, scripts)
+      files.should be_empty
+    end
+  end
+
   describe "#bundle_files" do
     it "throws ResourceNotFoundError exception if one of imported files not found" do
       #creating file with content with imported unexistent files