startback-websocket 0.14.0 → 0.14.1

data/spec/unit/support/test_env.rb

@@ -1,75 +0,0 @@
-require 'spec_helper'
-module Startback
-  module Support
-    describe Env do
-      include Env
-
-      before do
-        ENV['FOO'] = 'BAR'
-        ENV['FOOL'] = ''
-        ENV['FOOLISH'] = ' BAR '
-      end
-
-      after do
-        ENV.delete('FOO')
-        ENV.delete('FOOL')
-      end
-
-      describe "env" do
-        it 'returns an env variable' do
-          expect(env('FOO')).to eql('BAR')
-        end
-
-        it 'returns nil otherwise' do
-          expect(env('BAR')).to be_nil
-        end
-
-        it 'strips the value' do
-          expect(env('FOOLISH')).to eql('BAR')
-        end
-
-        it 'yields the block if any' do
-          expect(env('FOO'){|x| x.downcase }).to eql('bar')
-        end
-
-        it 'support a default value' do
-          expect(env('BAR', 'BAZ')).to eql('BAZ')
-        end
-
-        it 'yields the block with the default if any' do
-          expect(env('BAR', 'BAZ'){|x| x.downcase }).to eql('baz')
-        end
-
-        it 'returns nil when empty' do
-          expect(env('FOOL')).to be_nil
-        end
-
-        it 'yields the block with the default if empty' do
-          expect(env('FOOL', 'BAZ'){|x| x.downcase }).to eql('baz')
-        end
-      end
-
-      describe "env!" do
-        it 'returns an env variable' do
-          expect(env!('FOO')).to eql('BAR')
-        end
-
-        it 'strips the value' do
-          expect(env!('FOOLISH')).to eql('BAR')
-        end
-
-        it 'raise otherwise' do
-          expect{ env!('BAR') }.to raise_error(Startback::Errors::Error, /BAR/)
-        end
-
-        it 'raise on empty' do
-          expect{ env!('FOOL') }.to raise_error(Startback::Errors::Error, /FOOL/)
-        end
-
-        it 'yields the block if any' do
-          expect(env('FOO'){|x| x.downcase }).to eql('bar')
-        end
-      end
-    end
-  end
-end

data/spec/unit/support/test_robusteness.rb

@@ -1,229 +0,0 @@
-require 'spec_helper'
-module Startback
-  module Support
-    describe Robustness do
-
-      let(:the_logger) {
-        FakeLogger.new
-      }
-
-      let(:context_with_logger) {
-        Context.new.tap{|c| c.logger = the_logger }
-      }
-
-      describe "monitor" do
-        include Robustness
-
-        it 'works' do
-          x = monitor("test", context_with_logger) do
-            12
-          end
-          expect(x).to eql(12)
-          expect(the_logger.last_msg.keys).to eql([:op, :op_took])
-        end
-
-      end # monitor
-
-      describe "stop_errors" do
-        include Robustness
-
-        it 'works and logs the error' do
-          x = nil
-          expect {
-            x = stop_errors("test", context_with_logger) do
-              raise "Test"
-            end
-          }.not_to raise_error
-          expect(x).to be(nil)
-          expect(the_logger.last_msg.keys).to eql([:op, :op_took, :error])
-        end
-
-        it 'returns the result if no error' do
-          x = nil
-          expect {
-            x = stop_errors("test", context_with_logger) do
-              12
-            end
-          }.not_to raise_error
-          expect(x).to eql(12)
-          expect(the_logger.last_msg).to be_nil
-        end
-
-      end
-
-      describe "try_max_times" do
-        include Robustness
-
-        it 'fails if n errors are seen' do
-          seen = 0
-          expect {
-            try_max_times(2, "test", context_with_logger) do
-              seen += 1
-              raise "Test"
-            end
-          }.to raise_error("Test")
-          expect(seen).to eql(2)
-          expect(the_logger.last_msg.keys).to eql([:op, :op_took, :error])
-        end
-
-        it 'suceeds if an attemps succeeds' do
-          seen = 0
-          result = nil
-          expect {
-            result = try_max_times(2, "test", context_with_logger) do
-              seen += 1
-              raise "Test" if seen == 1
-              12
-            end
-          }.not_to raise_error
-          expect(result).to eql(12)
-          expect(seen).to eql(2)
-          expect(the_logger.last_msg.keys).to eql([:op, :op_took, :error])
-        end
-
-        it 'suceeds if first attemps succeeds' do
-          result = nil
-          expect {
-            result = try_max_times(2, "test", context_with_logger) do
-              12
-            end
-          }.not_to raise_error
-          expect(result).to eql(12)
-          expect(the_logger.last_msg).to be_nil
-        end
-
-      end
-
-      describe "parse_args" do
-        include Robustness::Tools
-
-        it 'works fine with full op and no context' do
-          log_msg_src = {
-            op: "AnOp",
-            op_data: { foo: "bar" }
-          }
-          log_msg, logger = parse_args(log_msg_src)
-          expect(log_msg).to eql(log_msg_src)
-          expect(logger).to be_a(::Logger)
-        end
-
-        it 'works fine with an string and a method name' do
-          expected = {
-            op: "AClass#method"
-          }
-          log_msg, logger = parse_args("AClass", "method")
-          expect(log_msg).to eql(expected)
-          expect(logger).to be_a(::Logger)
-        end
-
-        it 'works fine with an string, a method name, and a message' do
-          expected = {
-            op: "AClass#method",
-            op_data: { message: "Hello world" }
-          }
-          log_msg, logger = parse_args("AClass", "method", "Hello world")
-          expect(log_msg).to eql(expected)
-          expect(logger).to be_a(::Logger)
-        end
-
-        it 'works fine with a string only' do
-          expected = {
-            op: "a message"
-          }
-          log_msg, logger = parse_args("a message")
-          expect(log_msg).to eql(expected)
-          expect(logger).to be_a(::Logger)
-        end
-
-        it 'works fine with a Exception only' do
-          exception = StandardError.new('hello')
-          expected = {
-            error: exception
-          }
-          log_msg, logger = parse_args(exception)
-          expect(log_msg).to eql(expected)
-          expect(logger).to be_a(::Logger)
-        end
-
-        it 'works fine with a string and a context with logger' do
-          expected = {
-            op: "a message"
-          }
-          log_msg, logger = parse_args("a message", context_with_logger)
-          expect(log_msg).to eql(expected)
-          expect(logger).to be(the_logger)
-        end
-
-        it 'works fine with a string and an extra hash' do
-          expected = {
-            op: "a message",
-            op_took: 16
-          }
-          log_msg, logger = parse_args("a message", op_took: 16)
-          expect(log_msg).to eql(expected)
-          expect(logger).to be_a(::Logger)
-        end
-
-        it 'works fine with a module and method' do
-          expected = {
-            op: "Startback#foo"
-          }
-          log_msg, logger = parse_args(Startback, "foo")
-          expect(log_msg).to eql(expected)
-          expect(logger).to be_a(::Logger)
-        end
-
-        it 'works fine with a class and method' do
-          expected = {
-            op: "Startback::Event#foo"
-          }
-          log_msg, logger = parse_args(Startback::Event, "foo")
-          expect(log_msg).to eql(expected)
-          expect(logger).to be_a(::Logger)
-        end
-
-        it 'works fine with an instance and method' do
-          expected = {
-            op: "Startback::Event#foo"
-          }
-          log_msg, logger = parse_args(Startback::Event.new(nil, nil), "foo")
-          expect(log_msg).to eql(expected)
-          expect(logger).to be_a(::Logger)
-        end
-
-        it 'when a hash is passed as last arg' do
-          expected = {
-            op: "hello#foo",
-            op_took: 16
-          }
-          log_msg, logger = parse_args("hello", "foo", op_took: 16)
-          expect(log_msg).to eql(expected)
-          expect(logger).to be_a(::Logger)
-        end
-      end
-
-      describe "logger_for" do
-        include Robustness::Tools
-
-        it 'works on a logger' do
-          expect(logger_for(the_logger)).to be(the_logger)
-        end
-
-        it 'works on a Context responding to logger' do
-          expect(logger_for(context_with_logger)).to be(the_logger)
-        end
-
-        it 'works on an object having a Context responding to logger' do
-          x = OpenStruct.new(context: context_with_logger)
-          expect(logger_for(x)).to eql(the_logger)
-        end
-
-        it 'works on an object having a Context but no logger' do
-          x = OpenStruct.new(context: Context.new)
-          expect(logger_for(x)).to be_a(::Logger)
-        end
-      end
-
-    end
-  end
-end

data/spec/unit/support/test_transaction_manager.rb

@@ -1,64 +0,0 @@
-require 'spec_helper'
-module Startback
-  module Support
-    describe TransactionManager do
-      subject do
-        TransactionManager.new(db).call(nil, op) do
-          op.call
-        end
-      end
-
-      class FakeDatabase
-        def initialize
-          @called = false
-        end
-        attr_reader :called
-
-        def transaction
-          @called = true
-          yield
-        end
-      end
-
-      let(:db) do
-        FakeDatabase.new
-      end
-
-      context 'when called with a default operation' do
-        class OperationNotManagingTransactions < Startback::Operation
-          def call
-            12
-          end
-        end
-
-        let(:op) do
-          OperationNotManagingTransactions.new
-        end
-
-        it 'calls db.transaction' do
-          expect(subject).to eql(12)
-          expect(db.called).to eql(true)
-        end
-      end
-
-      context 'when called with an operation that manages the transactions itself' do
-        class OperationManagingTransactions < Startback::Operation
-          self.transaction_policy = :within_call
-
-          def call
-            12
-          end
-        end
-
-        let(:op) do
-          OperationManagingTransactions.new
-        end
-
-        it 'calls db.transaction' do
-          expect(subject).to eql(12)
-          expect(db.called).to eql(false)
-        end
-      end
-    end
-  end
-end

data/spec/unit/support/test_world.rb

@@ -1,72 +0,0 @@
-require 'spec_helper'
-
-module Startback
-  module Support
-    describe World do
-
-      let(:world) do
-        World.new
-      end
-
-      describe 'with' do
-        subject do
-          world.with(foo: :bar, bar: :baz)
-        end
-
-        it 'returns a new world instance' do
-          expect(subject).to be_a(World)
-          expect(subject).not_to be(world)
-        end
-
-        it 'gives access to those variables' do
-          expect(subject.foo).to eql(:bar)
-          expect(subject[:bar]).to eql(:baz)
-        end
-      end
-
-      describe 'dup' do
-        let(:world) do
-          World.new(foo: :bar)
-        end
-
-        subject do
-          world.dup
-        end
-
-        it 'returns another instance' do
-          expect(subject).to be_a(World)
-          expect(subject).not_to be(world)
-        end
-
-        it 'keeps variables' do
-          expect(subject.foo).to eql(:bar)
-        end
-      end
-
-      describe 'class factory' do
-        subject do
-          world.factory(:foo) do
-            hello
-          end
-        end
-
-        def hello
-          OpenStruct.new(bar: 12)
-        end
-
-        it 'returns a world instance' do
-          expect(subject).to be_a(World)
-          expect(subject).not_to be(world)
-        end
-
-        it 'installs the factory' do
-          bound = subject.with_scope(self)
-          got = bound.foo
-          expect(got).to be_a(OpenStruct)
-          expect(got.bar).to eql(12)
-          expect(bound.foo).to be(got)
-        end
-      end
-    end
-  end
-end

data/spec/unit/test_event.rb

@@ -1,62 +0,0 @@
-require 'spec_helper'
-
-module Startback
-  describe Event do
-
-    subject{
-      Event.new("User::Changed", { "foo" => "bar" })
-    }
-
-    it 'presents an ostruct on top of its data' do
-      expect(subject.data.foo).to eql("bar")
-    end
-
-    describe "the json information contract" do
-
-      JSON_SRC = <<-JSON.gsub(/\s+/, "")
-        {
-          "type": "User::Changed",
-          "data": {
-            "foo": "bar"
-          }
-        }
-      JSON
-
-      it 'has a to_json method that works as expected' do
-        expect(subject.to_json).to eql(JSON_SRC)
-      end
-
-      it 'has a to_json that dumps the context if any' do
-        evt = Event.new("User::Changed", { "foo" => "bar" }, { "baz": "context" })
-        expect(evt.to_json).to eql(<<-JSON.gsub(/\s+/, ""))
-          {
-            "type": "User::Changed",
-            "data": {
-              "foo": "bar"
-            },
-            "context": {
-              "baz": "context"
-            }
-          }
-        JSON
-      end
-
-
-      it 'has a json class method that works as expected' do
-        evt = Event.json(JSON_SRC, nil)
-        expect(evt).to be_a(Event)
-        expect(evt.type).to eql("User::Changed")
-        expect(evt.data).to eql(subject.data)
-      end
-
-      it 'accepts an explicit context as second argument' do
-        c = SubContext.new.tap{|x| x.foo = 'hello' }
-        evt = Event.json(JSON_SRC, c)
-        expect(evt.context).not_to be(c)
-        expect(evt.context).to be_a(SubContext)
-        expect(evt.context.foo).to eql('hello')
-      end
-    end
-
-  end
-end # module Startback

data/spec/unit/test_operation.rb

@@ -1,55 +0,0 @@
-require 'spec_helper'
-
-module Startback
-  describe Operation do
-
-    class FooOp < Operation
-
-      def initialize(foo = :bar)
-        @foo = foo
-      end
-      attr_accessor :foo
-
-      def call
-        @foo
-      end
-
-    end
-
-    it 'can be bound, which returns a new operation' do
-      foo1 = FooOp.new
-      foo1.foo = :bar1
-
-      foo2 = foo1.bind({ db: :bar })
-      expect(foo2.foo).to eql(:bar1)
-      expect(foo2.db).to eql(:bar)
-    end
-
-  end
-
-  describe Operation::MultiOperation do
-
-    it 'lets chain with +' do
-      mop = Operation::MultiOperation.new
-      mop2 = (mop + FooOp.new)
-
-      expect(mop == mop2).to eql(false)
-      expect(mop.size).to eql(0)
-      expect(mop2.size).to eql(1)
-    end
-
-    it 'calls and collects the result on call' do
-      mop = Operation::MultiOperation.new + FooOp.new(:hello) + FooOp.new(:world)
-      expect(mop.call).to eql([:hello, :world])
-    end
-
-    it 'binds every sub operation recursively' do
-      mop = Operation::MultiOperation.new + FooOp.new(:hello) + FooOp.new(:world)
-      mop2 = mop.bind({requester: :bar})
-
-      expect(mop == mop2).to eql(false)
-      expect(mop2.ops.all?{|op| op.requester == :bar })        
-    end
-
-  end
-end # module Startback

data/spec/unit/test_support.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-
-module Startback
-  describe Support do
-    include Support
-
-    describe "deep_merge" do
-
-      it 'works as expected' do
-        h1 = {
-          :foo => "bar",
-          :bar => "unchanged",
-          :baz => {
-            "hello" => "world",
-            "changed" => "yes"
-          }
-        }
-        h2 = {
-          :foo => "baz",
-          :baz => {
-            "eloy" => "tom",
-            "changed" => "no"
-          }
-        }
-        expected = {
-          :foo => "baz",
-          :bar => "unchanged",
-          :baz => {
-            "hello" => "world",
-            "eloy" => "tom",
-            "changed" => "no"
-          }
-        }
-        expect(deep_merge(h1, h2)).to eql(expected)
-      end
-
-    end
-
-  end
-end

data/spec/unit/web/fixtures/assets/app/hello.es6

@@ -1,4 +0,0 @@
-let test = (x) => {
-  console.log("Hello " + x)
-}
-test("world")

data/spec/unit/web/fixtures/assets/app/hello.html

@@ -1 +0,0 @@
-<p>Hello {{who}}</p>

data/spec/unit/web/fixtures/assets/index.es6

@@ -1 +0,0 @@
-//= require_tree ./app

data/spec/unit/web/test_api.rb

@@ -1,82 +0,0 @@
-require 'spec_helper'
-require 'startback/web/api'
-
-module Startback
-  module Web
-    describe Api do
-      include Rack::Test::Methods
-
-      class JsonDto
-        def to(accept, content_type)
-          ["application/json", %Q{{"foo":"bar"}}]
-        end
-      end
-
-      class PathDto
-        def to(accept, content_type)
-          ["text/plain", Path.file]
-        end
-      end
-
-      class DtoAble
-        def initialize(dto)
-          @dto = dto
-        end
-        def to_dto(context)
-          @dto
-        end
-      end
-
-      class TestedApi < ::Startback::Web::Api
-        get '/no-such-one' do
-          serve("Something", nil)
-        end
-
-        get '/entity' do
-          serve('Entity', {foo: "bar"})
-        end
-
-        get '/path' do
-          serve('Path', Path.file)
-        end
-
-        get '/dto-able' do
-          serve('DTO', DtoAble.new(JsonDto.new))
-        end
-
-        get '/dto-path' do
-          serve('DTO', DtoAble.new(PathDto.new))
-        end
-      end
-
-      let(:app) {
-        TestedApi
-      }
-
-      it 'convert nil to 404' do
-        get '/no-such-one'
-        expect(last_response.status).to eql(404)
-      end
-
-      it 'supports serving entities' do
-        get '/entity'
-        expect(last_response.body).to eql(%Q{{"foo":"bar"}})
-      end
-
-      it 'supports serving paths' do
-        get '/path'
-        expect(last_response.body).to eql(Path.file.read)
-      end
-
-      it 'supports serving DTO-able objects' do
-        get '/dto-able'
-        expect(last_response.body).to eql(%Q{{"foo":"bar"}})
-      end
-
-      it 'supports serving DTO-able objects eventually returning paths' do
-        get '/dto-path'
-        expect(last_response.body).to eql(Path.file.read)
-      end
-    end
-  end # module Web
-end # module Startback