startback 0.4.5 → 0.5.0

data/spec/unit/support/test_robusteness.rb

@@ -0,0 +1,209 @@
+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
+          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 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 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/test_context.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+module Startback
+  describe Context do
+
+    it "has a to_json that dumps it" do
+      expect(Context.new.to_json).to eql("{}")
+    end
+
+    class SubContext < Context
+      attr_accessor :foo
+      h_factory do |c,h|
+        c.foo = h["foo"]
+      end
+      h_dump do |h|
+        h.merge!("foo" => foo)
+      end
+    end
+ 
+    class SubContext
+      attr_accessor :bar
+      h_factory do |c,h|
+        c.bar = h["bar"]
+      end
+      h_dump do |h|
+        h.merge!("bar" => bar)
+      end
+    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/test_event.rb

@@ -0,0 +1,69 @@
+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)
+        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 in the world' do
+        evt = Event.json(JSON_SRC, context: 12)
+        expect(evt.context).to eql(12)
+      end
+
+      it 'accepts an context factory in the world' do
+        cf = ->(arg) {
+          expect(arg).to eql(JSON.parse(JSON_SRC))
+          12
+        }
+        evt = Event.json(JSON_SRC, context_factory: cf)
+        expect(evt.context).to eql(12)
+      end
+
+    end
+
+  end
+end # module Startback

data/spec/unit/test_operation.rb

@@ -21,10 +21,7 @@ module Startback
       foo1.foo = :bar1
 
       foo2 = foo1.bind({ db: :bar })
-      expect(foo1 == foo2).to eql(false)
       expect(foo2.foo).to eql(:bar1)
-
-      expect(->(){ foo1.db }).to raise_error(NoMethodError)
       expect(foo2.db).to eql(:bar)
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: startback
 version: !ruby/object:Gem::Version
-  version: 0.4.5
+  version: 0.5.0
 platform: ruby
 authors:
 - Bernard Lambeau
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-06-24 00:00:00.000000000 Z
+date: 2019-10-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -114,14 +114,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.6'
+        version: '0.7'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.6'
+        version: '0.7'
 - !ruby/object:Gem::Dependency
   name: path
   requirement: !ruby/object:Gem::Requirement
@@ -146,9 +146,20 @@ files:
 - README.md
 - Rakefile
 - lib/startback.rb
+- lib/startback/audit.rb
+- lib/startback/audit/trailer.rb
+- lib/startback/bus.rb
+- lib/startback/bus/bunny.rb
+- lib/startback/bus/bunny/async.rb
+- lib/startback/bus/memory.rb
+- lib/startback/bus/memory/async.rb
+- lib/startback/bus/memory/sync.rb
+- lib/startback/caching/entity_cache.rb
+- lib/startback/caching/store.rb
 - lib/startback/context.rb
 - lib/startback/context/middleware.rb
 - lib/startback/errors.rb
+- lib/startback/event.rb
 - lib/startback/ext.rb
 - lib/startback/ext/date_time.rb
 - lib/startback/ext/time.rb
@@ -156,7 +167,11 @@ files:
 - lib/startback/operation/error_operation.rb
 - lib/startback/operation/multi_operation.rb
 - lib/startback/support.rb
+- lib/startback/support/fake_logger.rb
+- lib/startback/support/hooks.rb
 - lib/startback/support/logger.rb
+- lib/startback/support/operation_runner.rb
+- lib/startback/support/robustness.rb
 - lib/startback/version.rb
 - lib/startback/web/api.rb
 - lib/startback/web/auto_caching.rb
@@ -166,9 +181,22 @@ files:
 - lib/startback/web/magic_assets.rb
 - lib/startback/web/magic_assets/ng_html_transformer.rb
 - lib/startback/web/magic_assets/rake_tasks.rb
+- lib/startback/web/middleware.rb
 - lib/startback/web/shield.rb
 - spec/spec_helper.rb
+- spec/unit/audit/test_trailer.rb
+- spec/unit/bus/memory/test_async.rb
+- spec/unit/bus/memory/test_sync.rb
+- spec/unit/caching/test_entity_cache.rb
+- spec/unit/context/test_abstraction_factory.rb
 - spec/unit/context/test_middleware.rb
+- spec/unit/support/hooks/test_after_hook.rb
+- spec/unit/support/hooks/test_before_hook.rb
+- spec/unit/support/operation_runner/test_around_run.rb
+- spec/unit/support/operation_runner/test_before_after_call.rb
+- spec/unit/support/test_robusteness.rb
+- spec/unit/test_context.rb
+- spec/unit/test_event.rb
 - spec/unit/test_operation.rb
 - spec/unit/test_support.rb
 - spec/unit/web/fixtures/assets/app/hello.es6