startback-websocket 0.14.0 → 0.14.1

data/spec/unit/web/test_auto_caching.rb

@@ -1,81 +0,0 @@
-require 'spec_helper'
-require 'startback/web/auto_caching'
-
-module Startback
-  module Web
-    describe AutoCaching do
-      include Rack::Test::Methods
-
-      context 'when used without options' do
-        def app
-          Rack::Builder.new do
-            use AutoCaching
-            run ->(env){ [200, {}, ["Hello error"]] }
-          end
-        end
-
-        it 'sets the development Cache-Control since this is a test' do
-          get '/'
-          expect(last_response['Cache-Control']). to eql("no-cache, no-store, max-age=0, must-revalidate")
-        end
-      end
-
-      context 'when forcing production' do
-        def app
-          Rack::Builder.new do
-            use AutoCaching, false
-            run ->(env){ [200, {}, ["Hello error"]] }
-          end
-        end
-
-        it 'sets the production Cache-Control' do
-          get '/'
-          expect(last_response['Cache-Control']). to eql("public, must-revalidate, max-age=3600, s-max-age=3600")
-        end
-      end
-
-      context 'when forcing development headers' do
-        def app
-          Rack::Builder.new do
-            use AutoCaching, development: { "Cache-Control" => "no-cache" }
-            run ->(env){ [200, {}, ["Hello error"]] }
-          end
-        end
-
-        it 'sets the production Cache-Control' do
-          get '/'
-          expect(last_response['Cache-Control']). to eql("no-cache")
-        end
-      end
-
-      context 'when setting the Cache-Control header only' do
-        def app
-          Rack::Builder.new do
-            use AutoCaching, development: "no-cache"
-            run ->(env){ [200, {}, ["Hello error"]] }
-          end
-        end
-
-        it 'sets the production Cache-Control' do
-          get '/'
-          expect(last_response['Cache-Control']). to eql("no-cache")
-        end
-      end
-
-      context 'when a Cache-Control header is already set by the app' do
-        def app
-          Rack::Builder.new do
-            use AutoCaching
-            run ->(env){ [200, {"Cache-Control" => "priority"}, ["Hello error"]] }
-          end
-        end
-
-        it 'sets the production Cache-Control' do
-          get '/'
-          expect(last_response['Cache-Control']). to eql("priority")
-        end
-      end
-
-    end # CatchAll
-  end # module Web
-end # module Startback

data/spec/unit/web/test_catch_all.rb

@@ -1,77 +0,0 @@
-require 'spec_helper'
-require 'singleton'
-require 'startback/web/catch_all'
-
-module Startback
-  module Web
-    describe CatchAll do
-      include Rack::Test::Methods
-
-      context 'when used without context' do
-        def app
-          Rack::Builder.new do
-            use CatchAll
-            run ->(env){ raise "Hello error" }
-          end
-        end
-
-        it 'returns a 500 with json explanation' do
-          get '/'
-          expect(last_response.status).to eql(500)
-          expect(last_response.content_type).to eql("application/json")
-          result = JSON.parse(last_response.body)
-          expect(result).to eql({
-            "code" => "Startback::Errors::InternalServerError",
-            "description" => "An error occured, sorry"
-          })
-        end
-      end
-
-      context 'when used with a context providing an error handler' do
-
-        class AnError < StandardError
-        end
-
-        class ErrorHandler
-          include Singleton
-
-          attr_reader :ex
-
-          def fatal(ex)
-            @ex = ex
-          end
-
-        end
-
-        class MyContextWithErrorHandler < Startback::Context
-
-          def error_handler
-            ErrorHandler.instance
-          end
-
-        end
-
-        def app
-          Rack::Builder.new do
-            use Context::Middleware, MyContextWithErrorHandler.new
-            use CatchAll
-            run ->(env){ raise AnError, "Hello error" }
-          end
-        end
-
-        it 'returns a 500 with json explanation' do
-          get '/'
-          expect(last_response.status).to eql(500)
-          expect(last_response.content_type).to eql("application/json")
-          result = JSON.parse(last_response.body)
-          expect(result).to eql({
-            "code" => "Startback::Errors::InternalServerError",
-            "description" => "An error occured, sorry"
-          })
-          expect(ErrorHandler.instance.ex).to be_a(AnError)
-        end
-      end
-
-    end # CatchAll
-  end # module Web
-end # module Startback

data/spec/unit/web/test_cors_headers.rb

@@ -1,88 +0,0 @@
-require 'spec_helper'
-require 'startback/web/cors_headers'
-
-module Startback
-  module Web
-    describe CorsHeaders do
-      include Rack::Test::Methods
-
-      context 'when used without options' do
-        def app
-          Rack::Builder.new do
-            use CorsHeaders
-            run ->(env){ [200, {}, ["Hello world"]] }
-          end
-        end
-
-        it 'sets the CORS headers to default values' do
-          header('Origin', "https://test.com")
-          get '/'
-          expect(last_response['Access-Control-Allow-Origin']). to eql("*")
-          expect(last_response['Access-Control-Allow-Methods']). to eql("OPTIONS, HEAD, GET, POST, PUT, PATCH, DELETE")
-          expect(last_response.body).to eql("Hello world")
-        end
-
-        it 'strips everything when option' do
-          header('Origin', "https://test.com")
-          options '/'
-          expect(last_response['Access-Control-Allow-Origin']). to eql("*")
-          expect(last_response['Access-Control-Allow-Methods']). to eql("OPTIONS, HEAD, GET, POST, PUT, PATCH, DELETE")
-          expect(last_response.status).to eql(204)
-          expect(last_response.body).to eql("")
-        end
-      end
-
-      context 'when used with the :bounce option' do
-        def app
-          Rack::Builder.new do
-            use CorsHeaders, bounce: true
-            run ->(env){ [200, {}, ["Hello world"]] }
-          end
-        end
-
-        it 'sets the CORS Origin header to the caller' do
-          header('Origin', "https://test.com")
-          get '/'
-          expect(last_response['Access-Control-Allow-Origin']). to eql("https://test.com")
-          expect(last_response['Access-Control-Allow-Methods']). to eql("OPTIONS, HEAD, GET, POST, PUT, PATCH, DELETE")
-          expect(last_response.body).to eql("Hello world")
-        end
-      end
-
-      context 'when overriding a header' do
-        def app
-          Rack::Builder.new do
-            use CorsHeaders, headers: { 'Access-Control-Allow-Methods' => "POST" }
-            run ->(env){ [200, {}, ["Hello world"]] }
-          end
-        end
-
-        it 'sets the CORS Origin header to the caller' do
-          header('Origin', "https://test.com")
-          get '/'
-          expect(last_response['Access-Control-Allow-Origin']). to eql("*")
-          expect(last_response['Access-Control-Allow-Methods']). to eql("POST")
-          expect(last_response.body).to eql("Hello world")
-        end
-      end
-
-      context 'when the app sets specific headers' do
-        def app
-          Rack::Builder.new do
-            use CorsHeaders
-            run ->(env){ [200, {'Access-Control-Allow-Methods' => "POST"}, ["Hello world"]] }
-          end
-        end
-
-        it 'does not override them' do
-          header('Origin', "https://test.com")
-          get '/'
-          expect(last_response['Access-Control-Allow-Origin']). to eql("*")
-          expect(last_response['Access-Control-Allow-Methods']). to eql("POST")
-          expect(last_response.body).to eql("Hello world")
-        end
-      end
-
-    end # CatchAll
-  end # module Web
-end # module Startback

data/spec/unit/web/test_healthcheck.rb

@@ -1,59 +0,0 @@
-require 'spec_helper'
-require 'startback/web/health_check'
-
-module Startback
-  module Web
-    describe HealthCheck do
-      include Rack::Test::Methods
-
-      context 'when used without a block and no failure' do
-        def app
-          HealthCheck.new
-        end
-
-        it 'returns a 204 when ok' do
-          get '/'
-          expect(last_response.status).to eql(204)
-          expect(last_response.body).to be_empty
-        end
-      end
-
-      context 'when used without a block a failure' do
-        def app
-          app = HealthCheck.new
-          def app.check!(env)
-            raise "Hello error"
-          end
-          app
-        end
-
-        it 'raises when ko' do
-          expect(->(){ get '/' }).to raise_error("Hello error")
-        end
-      end
-
-      context 'when used with a block returning a debug message' do
-        def app
-          HealthCheck.new{ "Hello world" }
-        end
-
-        it 'returns a 200 with plain text message' do
-          get '/'
-          expect(last_response.status).to eql(200)
-          expect(last_response.body).to eql("Hello world")
-        end
-      end
-
-      context 'when used with a block raising an exception' do
-        def app
-          HealthCheck.new{ raise("Hello error") }
-        end
-
-        it 're-raises it' do
-          expect(->(){ get '/' }).to raise_error("Hello error")
-        end
-      end
-
-    end
-  end # module Web
-end # module Startback

data/spec/unit/web/test_magic_assets.rb

@@ -1,82 +0,0 @@
-require 'spec_helper'
-require 'startback/web/magic_assets'
-require 'startback/web/magic_assets/ng_html_transformer'
-
-module Startback
-  module Web
-    describe MagicAssets do
-      include Rack::Test::Methods
-
-      context 'when used as an app' do
-        let(:app){
-          MagicAssets.new({
-            folder: Path.dir/"fixtures/assets"
-          })
-        }
-
-        it 'works as expected' do
-          get "/index.js"
-          expect(last_response.status).to eql(200)
-          expect(last_response.body).to match(/function test/)
-        end
-
-        it 'delegates a [] call to sprockets' do
-          result = app['index.js']
-          expect(result.to_s).to match(/function test/)
-        end
-
-        it 'returns a 404 on unknown' do
-          get '/nosuchone.js'
-          expect(last_response.status).to eql(404)
-        end
-      end
-
-      context 'when used as a middleware' do
-        let(:app){
-          Rack::Builder.new do
-            use MagicAssets, {
-              folder: Path.dir/"fixtures/assets",
-              path: "/my-assets"
-            }
-            run ->(t){
-              [200, {}, ["Hello world"]]
-            }
-          end
-        }
-
-        it 'lets unrelated things pass' do
-          get "/hello"
-          expect(last_response.status).to eql(200)
-          expect(last_response.body).to eql("Hello world")
-        end
-
-        it 'serves the assets under the chosen path' do
-          get "/my-assets/index.js"
-          expect(last_response.status).to eql(200)
-          expect(last_response.body).to match(/function test/)
-        end
-      end
-
-      context 'when registering the NgHtmlTransformer' do
-        let(:app){
-          plugin = MagicAssets::NgHtmlTransformer.new({
-            ng_module: "test.templates"
-          })
-          MagicAssets.new({
-            folder: Path.dir/"fixtures/assets",
-            plugins: [plugin]
-          })
-        }
-
-        it 'works as expected' do
-          get "/index.js"
-          expect(last_response.status).to eql(200)
-          expect(last_response.body).to match(/function test/)
-          expect(last_response.body).to match(/Hello \{\{who\}\}/)
-          expect(last_response.body).to match(/angular.module\("test.templates"\)/)
-        end
-      end
-
-    end
-  end
-end