zassets 0.2.7 → 0.2.8

data/spec/zassets/builder_spec.rb

@@ -1,52 +0,0 @@
-require 'spec_helper'
-
-module ZAssets
-  describe Builder do
-    let(:config)      { Config.new }
-    subject(:builder) { Builder.new(config) }
-
-    describe '#build' do
-      it 'compiles the manifest' do
-        builder.manifest = double('manifest')
-        expect(builder.manifest).to receive :compile
-        builder.build
-      end
-    end
-
-    describe '#manifest' do
-      it 'builds a sprockets manifest' do
-        expect(Sprockets::Manifest).to receive(:new).with(
-          builder.environment,
-          builder.manifest_path
-        )
-        builder.manifest
-      end
-
-      it 'returns the sprockets manifest' do
-        manifest = double('manifest')
-        allow(Sprockets::Manifest).to receive(:new) { manifest }
-        expect(builder.manifest).to be manifest
-      end
-    end
-
-    describe '#manifest_path' do
-      it 'returns the manifest file path' do
-        expected_path = File.join(config[:build_path], 'manifest.json')
-        expect(builder.manifest_path).to eq expected_path
-      end
-    end
-
-    describe '#environment' do
-      it 'builds a sprockets env' do
-        expect(SprocketsEnv).to receive(:new).with(config)
-        builder.environment
-      end
-
-      it 'returns the sprockets env' do
-        environment = double('environment')
-        allow(SprocketsEnv).to receive(:new) { environment }
-        expect(builder.environment).to be environment
-      end
-    end
-  end
-end

data/spec/zassets/cli_spec.rb

@@ -1,158 +0,0 @@
-require 'spec_helper'
-
-module ZAssets
-  describe CLI do
-    let(:args)    { ['serve'] }
-    subject(:cli) { CLI.new(args) }
-
-    describe '#initialize' do
-      context 'action arguments parsing' do
-        it 'parses the action' do
-          expect(cli.action).to eq :serve
-        end
-
-        context 'when action is not provided' do
-          let(:args) { [] }
-
-          it 'defaults to build' do
-            expect(cli.action).to eq :build
-          end
-        end
-      end
-
-      context 'option arguments parsing' do
-        def with_option(option, value = nil)
-          if value
-            CLI.new [option, value, *args]
-          else
-            CLI.new [option, *args]
-          end
-        end
-
-        it 'parses the -v option' do
-          expect(with_option('-v').options[:verbose]).to be true
-        end
-
-        it 'parses the -c option' do
-          expect(with_option('-c', 'config').options[:config_file])
-            .to eq 'config'
-        end
-
-        it 'parses the -o option' do
-          expect(with_option('-o', '::0').options[:host]).to eq '::0'
-        end
-
-        it 'parses the -p option' do
-          expect(with_option('-p', '9393').options[:port]).to eq '9393'
-        end
-
-        it 'parses the -s option' do
-          expect(with_option('-s', 'thin').options[:server]).to eq 'thin'
-        end
-
-        context '-h option' do
-          let(:args)    { ['-h'] }
-          let(:output)  { StringIO.new }
-          subject(:cli) { CLI.new(args, output) }
-
-          it 'prints the usage help' do
-            begin
-              cli
-            rescue SystemExit
-            end
-            expect(output.string).to match /\AUsage: /
-          end
-
-          it 'exits' do
-            expect { cli }.to raise_error SystemExit
-          end
-        end
-
-        context '-V option' do
-          let(:args)    { ['-V'] }
-          let(:output)  { StringIO.new }
-          subject(:cli) { CLI.new(args, output) }
-
-          it 'prints the version' do
-            begin
-              cli
-            rescue SystemExit
-            end
-            expect(output.string.chomp).to eq VERSION
-          end
-
-          it 'exits' do
-            expect { cli }.to raise_error SystemExit
-          end
-        end
-      end
-    end
-
-    describe '#action' do
-      it 'return the current action' do
-        expect(cli.action).to eq args.last.to_sym
-      end
-    end
-
-    describe '#config' do
-      it 'builds a config' do
-        expect(Config).to receive(:new).with(cli.options)
-        cli.config
-      end
-
-      it 'returns the config' do
-        config = double('config')
-        allow(Config).to receive(:new) { config }
-        expect(cli.config).to be config
-      end
-    end
-
-    describe '#run' do
-      context 'serve action' do
-        it 'runs the server' do
-          server = double('server')
-          allow(cli).to receive(:server) { server }
-          expect(server).to receive :run
-          cli.run
-        end
-      end
-
-      context 'build action' do
-        let(:args) { ['build'] }
-
-        it 'runs the builder' do
-          builder = double('builder')
-          allow(cli).to receive(:builder) { builder }
-          expect(builder).to receive :build
-          cli.run
-        end
-      end
-    end
-
-    describe '#builder' do
-      it 'builds a builder' do
-        expect(Builder).to receive(:new).with(cli.config)
-        cli.builder
-      end
-
-      it 'returns the builder' do
-        builder = double('builder')
-        allow(Builder).to receive(:new) { builder }
-        expect(cli.builder).to be builder
-      end
-    end
-
-    describe '#server' do
-      it 'builds a server' do
-        expect(Server).to receive(:new).with(cli.config)
-        cli.server
-      end
-
-      it 'returns the server' do
-        server = double('server')
-        allow(Server).to receive(:new) { server }
-        expect(cli.server).to be server
-      end
-    end
-  end
-end

data/spec/zassets/config_spec.rb

@@ -1,139 +0,0 @@
-require 'spec_helper'
-
-module ZAssets
-  describe Config do
-    include FixturesHelpers
-
-    let(:config_file) { fixture_path_for 'config/zassets.yaml' }
-    subject(:config)  { Config.new }
-
-    describe '#initialize' do
-      it 'assigns #default_options to @options' do
-        expect(config.instance_eval { @options }).to eq config.default_options
-      end
-
-      it 'registers plugins' do
-        expect_any_instance_of(Config).to receive :register_plugins!
-        Config.new
-      end
-
-      context 'with a non-empty option hash' do
-        it 'merges the option hash' do
-          config = Config.new(verbose: true)
-          expect(config[:verbose]).to be true
-        end
-      end
-
-      context 'with config_file option' do
-        subject(:config) { Config.new(config_file: config_file) }
-
-        it 'merges the config file options in @options' do
-          expect(config[:file_option]).to eq :file_value
-        end
-
-        it 'merges the config file options before argument options' do
-          config = Config.new(file_option: :argument_value)
-          expect(config[:file_option]).to eq :argument_value
-        end
-      end
-    end
-
-    describe '#default_options' do
-      it 'sets verbose to false' do
-        expect(config.default_options[:verbose]).to be false
-      end
-
-      it 'sets host to ::1' do
-        expect(config.default_options[:host]).to eq '::1'
-      end
-
-      it 'sets port to 9292' do
-        expect(config.default_options[:port]).to eq 9292
-      end
-
-      it 'sets server to puma' do
-        expect(config.default_options[:server]).to eq :puma
-      end
-
-      it 'sets base_url to /assets' do
-        expect(config.default_options[:base_url]).to eq '/assets'
-      end
-
-      it 'sets paths to app directory' do
-        expect(config.default_options[:paths]).to eq ['app']
-      end
-
-      it 'sets public_path to public directory' do
-        expect(config.default_options[:public_path]).to eq 'public'
-      end
-
-      it 'sets build_path to public/assets directory' do
-        expect(config.default_options[:build_path]).to eq 'public/assets'
-      end
-
-      it 'sets build empty' do
-        expect(config.default_options[:build]).to eq []
-      end
-    end
-
-    describe '#load_options' do
-      context 'when path is given as argument' do
-        it 'loads symbolized options from YAML file' do
-          expect(config.load_options(config_file)).to eq({
-            file_option: :file_value
-          })
-        end
-      end
-
-      context 'without argument' do
-        it 'loads the default config file path' do
-          expect { config.load_options }
-            .to raise_error /.*no such.+config\/zassets.yaml/i
-        end
-      end
-    end
-
-    describe '#default_config_file?' do
-      context 'when file does not exist' do
-        it 'returns false' do
-          expect(config.default_config_file?).to be false
-        end
-      end
-
-      context 'when file exists' do
-        it 'returns true' do
-          within_fixture_path do
-            expect(config.default_config_file?).to be true
-          end
-        end
-      end
-    end
-
-    describe '#register_plugins!' do
-      subject(:config) { Config.new(plugins: ['dummy']) }
-
-      it 'loads plugins' do
-        config
-        expect(Plugins::Dummy).to be
-      end
-
-      it 'registers them with current config' do
-        expect(config[:dummy_plugin]).to eq :registered
-      end
-    end
-
-    describe '#[]' do
-      it 'returns an @options value from its key' do
-        config.instance_eval { @options[:foo] = :bar }
-        expect(config[:foo]).to eq :bar
-      end
-    end
-
-    describe '#[]=' do
-      it 'stores a value under given key' do
-        config[:foo] = :bar
-        expect(config[:foo]).to eq :bar
-      end
-    end
-  end
-end

data/spec/zassets/memory_file_spec.rb

@@ -1,46 +0,0 @@
-require 'spec_helper'
-
-module ZAssets
-  describe MemoryFile do
-    include FixturesHelpers
-
-    let(:file_path)   { fixture_path_for('public/index.html') }
-    let(:file)        { File.new file_path }
-    subject(:memfile) { MemoryFile.new(file) }
-
-    describe '#headers' do
-      it 'sets the content type to text/html' do
-        expect(memfile.headers['Content-Type']).to eq 'text/html'
-      end
-
-      it 'sets the content length to the file length' do
-        expect(memfile.headers['Content-Length']).to eq file.size.to_s
-      end
-    end
-
-    describe '#body' do
-      it 'returns the file content' do
-        expect(memfile.body).to eq File.read(file_path)
-      end
-    end
-
-    describe '#call' do
-      require 'rack'
-
-      let(:app)       { Rack::MockRequest.new(memfile) }
-      let(:response)  { app.get '/' }
-
-      it 'returns a successful response' do
-        expect(response).to be_ok
-      end
-
-      it 'sets required headers' do
-        expect(response.headers).to eq memfile.headers
-      end
-
-      it 'returns the body' do
-        expect(response.body).to eq memfile.body
-      end
-    end
-  end
-end

data/spec/zassets/server_spec.rb

@@ -1,116 +0,0 @@
-require 'spec_helper'
-
-module ZAssets
-  describe Server do
-    let(:config)      { Config.new }
-    subject(:server)  { Server.new(config) }
-
-    describe '#run' do
-      let(:handler) { double 'handler' }
-
-      it 'runs the rack app' do
-        allow(server).to receive(:handler) { handler }
-        expect(handler).to receive(:run).with(server.app, server.options)
-        server.run
-      end
-    end
-
-    describe '#handler' do
-      it 'returns the configured rack handler' do
-        expect(server.handler).to eq Rack::Handler::Puma
-      end
-    end
-
-    describe '#options' do
-      it 'sets rack environment to development' do
-        expect(server.options[:environment]).to eq :development
-      end
-
-      it 'sets rack handler host to configured host' do
-        expect(server.options[:Host]).to eq config[:host]
-      end
-
-      it 'sets rack handler port to configured port' do
-        expect(server.options[:Port]).to eq config[:port]
-      end
-    end
-
-    describe '#app' do
-      it 'returns a rack application' do
-        expect(server.app).to respond_to :call
-      end
-
-      it 'builds the rack app once' do
-        # When building a rack app with Rack::Builder.new, the app will be
-        # built on each request. We dont want that so we need to either build
-        # using Rack::Builder.app or call #to_app on the returned instance. We
-        # can test if it was done by checking #to_app method absence.
-        expect(server.app).not_to respond_to :to_app
-      end
-
-      context 'Rack application' do
-        include FixturesHelpers
-
-        let(:app)       { Rack::MockRequest.new(server.app) }
-        let(:path)      { '/' }
-        let(:response)  { app.get path }
-
-        it 'logs queries' do
-          expect(response.errors).to match(/GET \/.+404.+/)
-        end
-
-        it 'shows exceptions' do
-          allow_any_instance_of(SprocketsEnv).to receive(:call) { raise RuntimeError }
-          response = app.get(config[:base_url])
-          expect(response).to be_server_error
-          expect(response.body).to match /RuntimeError/
-        end
-
-        context 'assets mount point' do
-          let(:path)    { [config[:base_url], 'app.js'].join '/' }
-          let(:config)  { Config.new(paths: [fixture_path_for('assets')]) }
-
-          it 'maps the sprockets env' do
-            within_fixture_path do
-              expect(response).to be_ok
-              expect(response.content_type).to eq 'application/javascript'
-              expect(response.body).to eq "console.log('hello!');\n"
-            end
-          end
-        end
-
-        context 'root mount point' do
-          let(:path) { '/hello.txt' }
-
-          it 'maps the static file handler' do
-            within_fixture_path do
-              expect(response).to be_ok
-              expect(response.content_type).to eq 'text/plain'
-              expect(response.body).to eq "hello!\n"
-            end
-          end
-
-          context 'when a public file is configured' do
-            let(:config) { Config.new(public_file: 'index.html') }
-
-            it 'serves the public file' do
-              within_fixture_path do
-                response = app.get('/')
-                expect(response).to be_ok
-                expect(response.content_type).to eq 'text/html'
-                expect(response.body).to eq "hello HTML!\n"
-              end
-            end
-
-            it 'serves static file' do
-              within_fixture_path do
-                response = app.get('/hello.txt')
-                expect(response.body).to eq "hello!\n"
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end