startback-websocket 0.14.0 → 0.14.1

data/spec/unit/context/test_h_factory.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-
-module Startback
-  describe Context, "h information contract" do
-
-    it "has a to_json that dumps it" do
-      expect(Context.new.to_json).to eql("{}")
-    end
-
-    it 'allows installing factories' do
-      expect(Context.h_factories).to be_empty
-      expect(SubContext.h_factories.size).to eql(2)
-    end
-
-    it 'has a `to_h` information contract that works as expected' do
-      context = SubContext.new.tap{|c|
-        c.foo = "Hello"
-        c.bar = "World"
-      }
-      expect(context.to_h).to eql({ "foo" => "Hello", "bar" => "World" })
-    end
-
-    it 'has a `h` information contract that works as expected' do
-      context = SubContext.h({ "foo" => "Hello", "bar" => "World" })
-      expect(context).to be_a(SubContext)
-      expect(context.foo).to eql("Hello")
-      expect(context.bar).to eql("World")
-    end
-
-  end
-end

data/spec/unit/context/test_middleware.rb

@@ -1,45 +0,0 @@
-require 'spec_helper'
-
-module Startback
-  class Context
-
-    class MyContextSubClass < Context
-    end
-
-    describe Middleware do
-      include Rack::Test::Methods
-
-      def app
-        build_args = self.build_args
-        Rack::Builder.new do
-          use Middleware, *build_args
-          run ->(env){
-            ctx = env[Startback::Context::Middleware::RACK_ENV_KEY]
-            [200, {}, ctx.class.to_s]
-          }
-        end
-      end
-
-      context 'when used without context' do
-        let(:build_args){ [] }
-
-        it 'sets the default context class' do
-          get '/'
-          expect(last_response.status).to eql(200)
-          expect(last_response.body).to eql("Startback::Context")
-        end
-      end
-
-      context 'when specifying the context class' do
-        let(:build_args){ [MyContextSubClass.new] }
-
-        it 'sets the default context class' do
-          get '/'
-          expect(last_response.status).to eql(200)
-          expect(last_response.body).to eql("Startback::Context::MyContextSubClass")
-        end
-      end
-
-    end
-  end # module Web
-end # module Startback

data/spec/unit/context/test_with_world.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-
-module Startback
-  describe Context, "with_world" do
-
-    let(:who) do
-      Object.new
-    end
-
-    let(:context) do
-      SubContext.new.with_world(hello: who)
-    end
-
-    it 'works as expected' do
-      got = context.world.hello
-      expect(got).to be(who)
-    end
-
-  end
-end

data/spec/unit/context/test_world.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-
-module Startback
-  describe Context, "world" do
-
-    let(:context) do
-      SubContext.new
-    end
-
-    it 'works as expected' do
-      got = context.world.partner
-      expect(got).not_to be_nil
-      expect(context.world.partner).to be(got)
-    end
-
-  end
-end

data/spec/unit/event/bus/memory/test_async.rb

@@ -1,43 +0,0 @@
-require 'spec_helper'
-module Startback
-  class Event
-    describe Bus::Memory do
-
-      subject{
-        Bus::Memory::Async.new
-      }
-
-      it 'allows emiting an receiving' do
-        seen = nil
-        subject.listen("user_changed") do |evt|
-          seen = evt
-        end
-        subject.emit(Event.new("user_changed", {id: 12}))
-        expect(seen).to be_a(Event)
-        expect(seen.type).to eql("user_changed")
-        expect(seen.data.to_h).to eql({id: 12})
-      end
-
-      it 'allows mixin Symbol vs. String for event type' do
-        seen = nil
-        subject.listen(:user_changed) do |evt|
-          seen = evt
-        end
-        subject.emit(Event.new(:user_changed, {id: 12}))
-        expect(seen).to be_a(Event)
-        expect(seen.type).to eql("user_changed")
-        expect(seen.data.to_h).to eql({id: 12})
-      end
-
-      it 'does not raise errors synchronously' do
-        subject.listen("user_changed") do |evt|
-          raise "An error occured"
-        end
-        expect {
-          subject.emit(Event.new("user_changed", {id: 12}))
-        }.not_to raise_error
-      end
-
-    end
-  end
-end

data/spec/unit/event/bus/memory/test_sync.rb

@@ -1,43 +0,0 @@
-require 'spec_helper'
-module Startback
-  class Event
-    describe Bus::Memory do
-
-      subject{
-        Bus::Memory::Sync.new
-      }
-
-      it 'allows emiting an receiving' do
-        seen = nil
-        subject.listen("user_changed") do |evt|
-          seen = evt
-        end
-        subject.emit(Event.new("user_changed", {id: 12}))
-        expect(seen).to be_a(Event)
-        expect(seen.type).to eql("user_changed")
-        expect(seen.data.to_h).to eql({id: 12})
-      end
-
-      it 'allows mixin Symbol vs. String for event type' do
-        seen = nil
-        subject.listen(:user_changed) do |evt|
-          seen = evt
-        end
-        subject.emit(Event.new(:user_changed, {id: 12}))
-        expect(seen).to be_a(Event)
-        expect(seen.type).to eql("user_changed")
-        expect(seen.data.to_h).to eql({id: 12})
-      end
-
-      it 'raises emit errors synchronously' do
-        subject.listen("user_changed") do |evt|
-          raise "An error occured"
-        end
-        expect {
-          subject.emit(Event.new("user_changed", {id: 12}))
-        }.to raise_error("An error occured")
-      end
-
-    end
-  end
-end

data/spec/unit/support/hooks/test_after_hook.rb

@@ -1,54 +0,0 @@
-require 'spec_helper'
-require 'singleton'
-module Startback
-  module Support
-    describe Hooks, "after_xxx" do
-
-      class AfterHooked
-        include Hooks.new(:xxx)
-
-        def initialize
-          super
-          @after_called = false
-        end
-        attr_accessor :after_called
-
-        after_xxx do
-          self.after_called = true
-        end
-
-      end
-
-      class SubAfterHooked < AfterHooked
-
-        def initialize
-          super
-          @subafter_called = false
-        end
-        attr_accessor :subafter_called
-
-        after_xxx do
-          self.subafter_called = true
-        end
-
-      end
-
-      it 'works as expected' do
-        h = AfterHooked.new
-        expect(h.after_called).to eql(false)
-        h.after_xxx
-        expect(h.after_called).to eql(true)
-      end
-
-      it 'works as expected on subclass' do
-        h = SubAfterHooked.new
-        expect(h.after_called).to eql(false)
-        expect(h.subafter_called).to eql(false)
-        h.after_xxx
-        expect(h.after_called).to eql(true)
-        expect(h.subafter_called).to eql(true)
-      end
-
-    end
-  end
-end

data/spec/unit/support/hooks/test_before_hook.rb

@@ -1,54 +0,0 @@
-require 'spec_helper'
-require 'singleton'
-module Startback
-  module Support
-    describe Hooks, "before_xxx" do
-
-      class BeforeHooked
-        include Hooks.new(:xxx)
-
-        def initialize
-          super
-          @before_called = false
-        end
-        attr_accessor :before_called
-
-        before_xxx do
-          self.before_called = true
-        end
-
-      end
-
-      class SubBeforeHooked < BeforeHooked
-
-        def initialize
-          super
-          @subbefore_called = false
-        end
-        attr_accessor :subbefore_called
-
-        before_xxx do
-          self.subbefore_called = true
-        end
-
-      end
-
-      it 'works as expected' do
-        h = BeforeHooked.new
-        expect(h.before_called).to eql(false)
-        h.before_xxx
-        expect(h.before_called).to eql(true)
-      end
-
-      it 'works as expected on subclass' do
-        h = SubBeforeHooked.new
-        expect(h.before_called).to eql(false)
-        expect(h.subbefore_called).to eql(false)
-        h.before_xxx
-        expect(h.before_called).to eql(true)
-        expect(h.subbefore_called).to eql(true)
-      end
-
-    end
-  end
-end

data/spec/unit/support/operation_runner/test_around_run.rb

@@ -1,156 +0,0 @@
-require 'spec_helper'
-require 'singleton'
-module Startback
-  module Support
-    describe OperationRunner, "around_run" do
-
-      class OperationTest < Startback::Operation
-
-        def call
-          { seen_hello: hello }
-        end
-
-      end
-
-      let(:op) {
-        OperationTest.new
-      }
-
-      context 'the simplest contract' do
-        class RunnerTest1
-          include OperationRunner
-
-          def operation_world(op)
-            { hello: "world"}
-          end
-        end
-
-        it 'lets run an operation with world bound' do
-          expect(RunnerTest1.new.run(op)).to eql({
-            seen_hello: "world"
-          })
-        end
-      end
-
-      context 'the around feature' do
-        class RunnerTest2
-          include OperationRunner
-
-          def initialize
-            @arounds = []
-          end
-          attr_reader :arounds
-
-          around_run do |o, then_block|
-            raise unless o.is_a?(OperationTest)
-            arounds << "hello"
-            then_block.call
-          end
-
-          around_run do |_, then_block|
-            arounds << "world"
-            then_block.call
-          end
-
-          def operation_world(op)
-            { hello: "world" }
-          end
-        end
-
-        it 'calls the around before the operation itself' do
-          test = RunnerTest2.new
-          got = test.run(op)
-          expect(test.arounds).to eql(["hello", "world"])
-          expect(got).to eql({
-            seen_hello: "world"
-          })
-        end
-      end
-
-      context 'the around feature with a class' do
-        class SomeTransactionManager
-          include Singleton
-
-          def initialize
-            @called = false
-          end
-          attr_reader :called
-
-          def call(runner, op)
-            raise unless runner.is_a?(RunnerTest3)
-            raise unless op.is_a?(OperationTest)
-            @called = true
-            yield
-          end
-
-        end
-
-        class RunnerTest3
-          include OperationRunner
-          around_run SomeTransactionManager.instance
-
-          def operation_world(op)
-            { hello: "world" }
-          end
-        end
-
-        it 'calls the proc with expected parameters' do
-          test = RunnerTest3.new
-          got = test.run(op)
-          expect(SomeTransactionManager.instance.called).to eql(true)
-          expect(got).to eql({
-            seen_hello: "world"
-          })
-        end
-      end
-
-      context 'the around feature with a subclass' do
-        class RunnerTest4
-          include OperationRunner
-
-          def initialize
-            @called = false
-          end
-          attr_reader :called
-
-          around_run do |o,t|
-            raise unless o.is_a?(OperationTest)
-            @called = true
-            t.call
-          end
-        end
-
-        class RunnerTest5 < RunnerTest4
-
-          def initialize
-            super
-            @subcalled = false
-          end
-          attr_reader :subcalled
-
-          around_run do |o,t|
-            raise unless o.is_a?(OperationTest)
-            @subcalled = true
-            t.call
-          end
-
-          def operation_world(op)
-            { hello: "world" }
-          end
-        end
-
-        it 'executes all hooks' do
-          test = RunnerTest5.new
-          got = test.run(op)
-          expect(test.called).to be(true)
-          expect(test.subcalled).to be(true)
-          expect(got).to eql({
-            seen_hello: "world"
-          })
-        end
-
-      end
-
-    end # module OperationRunner
-  end # module Support
-end # module Startback

data/spec/unit/support/operation_runner/test_before_after_call.rb

@@ -1,48 +0,0 @@
-require 'spec_helper'
-require 'singleton'
-module Startback
-  module Support
-    describe OperationRunner, "before_call" do
-
-      class OperationTestBeforeCall < Operation
-
-        def initialize
-          before_called = false
-        end
-        attr_accessor :before_called
-
-        before_call do
-          self.before_called = true
-        end
-
-        def call
-          {
-            seen_hello: "world"
-          }
-        end
-
-      end
-
-      let(:op) {
-        OperationTestBeforeCall.new
-      }
-
-      class RunnerTest1
-        include OperationRunner
-
-        def operation_world(op)
-          { hello: "world" }
-        end
-      end
-
-      it 'runs before the around hooks' do
-        expect(RunnerTest1.new.run(op)).to eql({
-          seen_hello: "world"
-        })
-        expect(op.before_called).to eql(true)
-      end
-
-
-    end
-  end
-end

data/spec/unit/support/test_data_object.rb

@@ -1,156 +0,0 @@
-require 'spec_helper'
-
-module Startback
-  module Support
-    describe DataObject do
-
-      class FooDataObject
-        include DataObject
-      end
-
-      let(:data) do
-        {
-          :foo => 'bar',
-          'bar' => 'baz'
-        }
-      end
-
-      subject do
-        FooDataObject.new(data)
-      end
-
-      it 'lets create an instance with providing data' do
-        expect(subject).to be_a(FooDataObject)
-      end
-
-      it 'lets get the data back' do
-        expect(subject.to_data).to eql(data)
-        expect(subject.to_data).not_to be(data)
-      end
-
-      it 'lets to_json it' do
-        expect(subject.to_json).to eql(%Q{{"foo":"bar","bar":"baz"}})
-      end
-
-      describe "data helpers" do
-        it 'lets access data through methods' do
-          expect(subject.foo).to eql('bar')
-        end
-
-        it 'is indifferent to symbol vs. string' do
-          expect(subject.bar).to eql('baz')
-        end
-
-        it 'is indifferent to camel casing' do
-          expect(subject.bar).to eql('baz')
-        end
-
-        it 'raises a NoMethodError when not known' do
-          expect {
-            subject.no_such_one
-          }.to raise_error(NoMethodError)
-        end
-
-        it 'implements respond_to? correctly' do
-          expect(subject.respond_to?(:foo)).to eql(true)
-          expect(subject.respond_to?(:bar)).to eql(true)
-          expect(subject.respond_to?(:no_such_one)).to eql(false)
-        end
-      end # data helpers
-
-      describe "? helpers" do
-        let(:data) do
-          {
-            'some' => 'thing',
-            'ready' => false,
-            'unready' => true,
-            'nothing' => nil
-          }
-        end
-
-        it 'works as expected' do
-          expect(subject.some?).to eql(true)
-          expect(subject.ready?).to eql(false)
-          expect(subject.unready?).to eql(true)
-          expect(subject.nothing?).to eql(false)
-        end
-
-        it 'implements respond_to? correctly' do
-          expect(subject.respond_to?(:some?)).to eql(true)
-          expect(subject.respond_to?(:ready?)).to eql(true)
-          expect(subject.respond_to?(:unready?)).to eql(true)
-          expect(subject.respond_to?(:nothing?)).to eql(true)
-        end
-
-        it 'stays conservative' do
-          expect {
-            subject.no_such_one?
-          }.to raise_error(NoMethodError)
-          expect(subject.respond_to?(:no_such_one?)).to eql(false)
-        end
-      end
-
-      describe "case helpers" do
-        let(:data) do
-          {
-            'camelCase' => 'snake_case'
-          }
-        end
-
-        it 'lets use camelCase' do
-          expect(subject.camelCase).to eql('snake_case')
-        end
-
-        it 'lets use camel_case' do
-          expect(subject.camel_case).to eql('snake_case')
-        end
-
-        it 'implements respond_to? correctly' do
-          expect(subject.respond_to?(:camelCase)).to eql(true)
-          expect(subject.respond_to?(:camel_case)).to eql(true)
-        end
-
-        it 'is compatible with ? helpers' do
-          expect(subject.camelCase?).to eql(true)
-          expect(subject.camel_case?).to eql(true)
-        end
-
-        it 'stays conservative' do
-          expect {
-            subject.no_such_one
-          }.to raise_error(NoMethodError)
-          expect(subject.respond_to?(:no_such_one)).to eql(false)
-          expect(subject.respond_to?(:no_such_one?)).to eql(false)
-        end
-      end
-
-      describe '[]' do
-        let(:data) do
-          {
-            :foo => 'bar',
-            'bar' => 'baz',
-            'camelCase' => 'snake_case'
-          }
-        end
-
-        it 'lets access data' do
-          expect(subject[:foo]).to eql('bar')
-          expect(subject['bar']).to eql('baz')
-          expect(subject['camelCase']).to eql('snake_case')
-        end
-
-        it 'uses indifferent access' do
-          expect(subject['foo']).to eql('bar')
-          expect(subject[:bar]).to eql('baz')
-          expect(subject[:camelCase]).to eql('snake_case')
-        end
-
-        it 'has no other magic and returns nil in all other cases' do
-          expect(subject[:foo?]).to be_nil
-          expect(subject[:camel_case]).to be_nil
-          expect(subject[:camel_case?]).to be_nil
-        end
-      end
-    end
-  end
-end