adalog 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9e726549691167f64945f6d0bd5057b79fb210db
-  data.tar.gz: d9df52ddb63df02578a5b1eb84d16f60dcc5ceba
+  metadata.gz: 4234965ef03a7ffddfd7e02bc88a31fb61916e56
+  data.tar.gz: 5ae14eb814ce16a28e5780421183583f3d6565bc
 SHA512:
-  metadata.gz: 1ade73f1d7180ae64863936d8bb28796132170a1d3331c3d7a651ebb5a033ec91df1bc759a06644a380c70f25f9d54b3767801cb86b6f249043cfdcd88a7574f
-  data.tar.gz: 5315dcf3c987dd18f6c5a9b5adca744b7ce53bde65ba85b237b94f80e54eaa45530efa95122730751f756da614e8e2d1337e8c92325a31ad3d5e0c472ed61f31
+  metadata.gz: e49c93e19ea49fc9a31ed021c1ce2a147ab81d4490a0b5ac02747539b931f55d654026c743fdccde3d90ba814e37a1753e195c49d16202d1cf369851c7522176
+  data.tar.gz: 83557e9aad1ea5a311076435393a0c7c6b92d97f208392c04fdac01ba2983ac1d5659f73b1d5582cbd953e7befc3123df70719f128e04f9bcb0301b4800f4e62

data/.gitignore

@@ -27,3 +27,5 @@ rdoc
 test/tmp
 test/version_tmp
 config.ru
+.env
+.env*

data/lib/adalog/mock_logging_adapter.rb

@@ -0,0 +1,142 @@
+module Adalog
+  module MockLoggingAdapter
+
+    ##
+    # A factory to make new classes which implement the MockLogging
+    def self.new(service_name, repo, **stub_methods)
+      new_logger_class = Class.new(self::Base)
+      new_logger_class.instance_variable_set(:@service_name, service_name)
+      new_logger_class.instance_variable_set(:@repo, repo)
+
+      stub_methods.each do |message, value|
+        new_logger_class.instance_exec do
+          define_method(message, &MockLoggingAdapter.stub_method(message, value))
+        end
+      end
+
+      new_logger_class
+    end
+
+    ##
+    # An isolated lambda to serve as the method body for stubs, both in
+    # the ::new method and in the Base#initialize method.
+    # Avoids repeating already clunky-looking logic.
+    def self.stub_method(message, value)
+      ->(*args, **kwargs, &block) {
+        _received_messages << ReceivedMessage.new(message, args, kwargs, block)
+        repo.insert(
+          title:    service_name,
+          message:  "'#{message}', which has been stubbed with '#{value}'.",
+          details:  args)
+        block.call unless nil == block
+        value
+      }
+    end
+
+    ##
+    # A class to encapsulate the data logged for received messages and all
+    # of their arguments.
+    ReceivedMessage = Struct.new(:message, :args, :kwargs, :block) do
+
+      ##
+      # Just a little alias in case you're not as used to, or comfortable with,
+      # referring to Ruby method calls as 'messages' that are sent and received.
+      # But should be.
+      # Because that's what they are.
+      def name
+        message
+      end
+
+      ##
+      # A handy list of the received arguments, without the message name.
+      def arguments
+        result  = []
+        result += args
+        result << kwargs unless kwargs.empty?
+        result
+      end
+
+    end
+
+    ##
+    # Used as the superclass of all logging classes returned from ::new
+    class Base
+
+      ##
+      # Store the service_name and repo at the class level rather than coming up with some
+      # way of shoehorning it into each instance directly.
+      class << self
+        def service_name; @service_name ; end
+        def repo        ; @repo         ; end
+      end
+
+      ##
+      # Allows for overriding stubbed methods which were initially built into the mock adapter.
+      # Does not explicitly restrict "overriding" to existing stubs, and so can be used to add
+      # additional stubs to a specific instance.
+      def initialize(**stub_method_overrides)
+        stub_method_overrides.each do |message, value|
+          define_singleton_method(message, &MockLoggingAdapter.stub_method(message, value))
+        end
+      end
+
+      ##
+      # Convenience instance method versions of class-level storage of service_name and repo.
+      def service_name; self.class.service_name ; end
+      def repo        ; self.class.repo         ; end
+
+      ##
+      # Reader for the messages received by this mock, perhaps for use in testing
+      # details of particular calls.
+      def messages
+        _received_messages
+      end
+
+      ##
+      # For use in simple boolean asserts, if all you need to test is the number of
+      # times a message was received. Flexible keyword arguments, which the the following
+      # precedence and details:
+      # - If :exactly is specified, will return true only if the message count is exactly the
+      #   value of :exactly.
+      # - When :exactly is specified, :at_least and :at_most are ignored.
+      # - If :at_least is specified, will return true only if the message count is equal to or
+      #   greater than the value of :at_least.
+      # - If :at_most is specified, will return true only if the message count is equal to or
+      #   less than the value of :at_most.
+      # - :at_least and :at_most can be used simultaneously, and will return true if the
+      #   message count falls in the range (at_least..at_most), that is, inclusive.
+      # - If no keyword options are specified, the default behavior is equivalent to
+      #   calling with the option `at_least: 1`.
+      #
+      # Consequently, this method is as flexible as possible, to allow for expressive
+      # assertions in tests, such as:
+      #   received?('unsubscribe', at_least: 1)
+      #   received?('generate', exactly: 3)
+      #   received?('toggle', at_least: 2, at_most: 4)
+      #
+      def received?(message, exactly: :none, at_least: :none, at_most: :none)
+        recv_count = _received_messages.select { |recv| recv.message == message }.count
+
+        return recv_count == exactly unless :none == exactly
+        # Substitute a default "at_least: 1" behavior for no options given.
+        if :none == at_least and :none == at_most
+          at_least = 1
+        end
+
+        result = true
+        result = result && recv_count >= at_least unless :none == at_least
+        result = result && recv_count <= at_most  unless :none == at_most
+        result
+      end
+
+      ##
+      # In case the service needs to stub-out a method named 'messages', we have
+      # this more direct, internal method name.
+      def _received_messages
+        @_received_messages ||= []
+      end
+
+    end
+
+  end
+end

data/lib/adalog/stub_logging_adapter.rb

@@ -0,0 +1,65 @@
+module Adalog
+  module StubLoggingAdapter
+
+    ##
+    # A factory to make new classes which implement the MockLogging
+    def self.new(service_name, repo, **stub_methods)
+      new_logger_class = Class.new(self::Base)
+      new_logger_class.instance_variable_set(:@service_name, service_name)
+      new_logger_class.instance_variable_set(:@repo, repo)
+
+      stub_methods.each do |message, value|
+        new_logger_class.instance_exec do
+          define_method(message, &StubLoggingAdapter.stub_method(message, value))
+        end
+      end
+
+      new_logger_class
+    end
+
+    ##
+    # An isolated lambda to serve as the method body for stubs, both in
+    # the ::new method and in the Base#initialize method.
+    # Avoids repeating already clunky-looking logic.
+    def self.stub_method(message, value)
+      ->(*args, &block) {
+        repo.insert(
+          title:    service_name,
+          message:  "'#{message}', which has been stubbed with '#{value}'.",
+          details:  args)
+        block.call unless nil == block
+        value
+      }
+    end
+
+    ##
+    # Used as the superclass of all logging classes returned from ::new
+    class Base
+
+      ##
+      # Store the service_name and repo at the class level rather than coming up with some
+      # way of shoehorning it into each instance directly.
+      class << self
+        def service_name; @service_name ; end
+        def repo        ; @repo         ; end
+      end
+
+      ##
+      # Allows for overriding stubbed methods which were initially built into the mock adapter.
+      # Does not explicitly restrict "overriding" to existing stubs, and so can be used to add
+      # additional stubs to a specific instance.
+      def initialize(**stub_method_overrides)
+        stub_method_overrides.each do |message, value|
+          define_singleton_method(message, &StubLoggingAdapter.stub_method(message, value))
+        end
+      end
+
+      ##
+      # Convenience instance method versions of class-level storage of service_name and repo.
+      def service_name; self.class.service_name ; end
+      def repo        ; self.class.repo         ; end
+
+    end
+
+  end
+end

data/lib/adalog/version.rb

@@ -1,3 +1,3 @@
 module Adalog
-  VERSION = "0.4.1"
+  VERSION = "0.5.0"
 end

data/test/unit/mock_logging_adapter_test.rb

@@ -0,0 +1,287 @@
+require 'test_helper'
+
+class MockLoggingAdapterTest < Minitest::Test
+
+  def setup
+    @default_repo = Adalog::InMemoryRepo.new
+  end
+
+
+  def default_repo
+    @default_repo ||= Adalog::InMemoryRepo.new
+  end
+
+
+  def tg_service_adapter
+    stub_methods  = { generate: Object.new, toggle: true }
+    adapter_class = Adalog::MockLoggingAdapter.new('TGService', default_repo, **stub_methods)
+  end
+
+
+  def build_tg_service_adapter
+    tg_service_adapter.new
+  end
+
+
+################################################################################
+## The first tests are identical to those for StubLoggingAdapter.             ##
+## This is because MockLoggingAdapter is a superset of that functionality.    ##
+## A future refactoring may involve unifying these tests more elegantly,      ##
+## either in terms of the classes themselves, or by just unifying the tests   ##
+## as they are presented in test files themselves.                            ##
+################################################################################
+
+
+  test "new creates a logging adapter class" do
+    adapter_class = Adalog::MockLoggingAdapter.new('SomeService', default_repo)
+    assert_kind_of(Class, adapter_class)
+  end
+
+
+  test "class accessors for service_name and repo" do
+    adapter_class = Adalog::MockLoggingAdapter.new('SomeService', default_repo)
+    assert_respond_to(adapter_class, :service_name)
+    assert_respond_to(adapter_class, :repo)
+    adapter = adapter_class.new
+    assert_equal('SomeService', adapter.service_name)
+    assert_equal(default_repo, adapter.repo)
+  end
+
+
+  test "instance methods are created for stubs specified in new" do
+    stub_methods  = { foo: 'bar', one: 1, two: 2 }
+    adapter_class = Adalog::MockLoggingAdapter.new('SomeService', default_repo, **stub_methods)
+    adapter       = adapter_class.new
+    assert_respond_to(adapter, :foo)
+    assert_respond_to(adapter, :one)
+    assert_respond_to(adapter, :two)
+  end
+
+
+  test "stubbed instance methods return provided stubbed values" do
+    stub_methods  = { foo: 'bar', one: 1, two: 2 }
+    adapter_class = Adalog::MockLoggingAdapter.new('SomeService', default_repo, **stub_methods)
+    adapter       = adapter_class.new
+    assert_equal('bar', adapter.foo)
+    assert_equal(1,     adapter.one)
+    assert_equal(2,     adapter.two)
+  end
+
+
+  test "new stubs can be added at instantiation" do
+    stub_methods  = { foo: 'bar', one: 1, two: 2 }
+    adapter_class = Adalog::MockLoggingAdapter.new('SomeService', default_repo, **stub_methods)
+    adapter       = adapter_class.new(baz: 'bim')
+    assert_respond_to(adapter, :baz)
+    assert_equal('bim', adapter.baz)
+  end
+
+
+  test "stubs can be overridden at instantiation" do
+    stub_methods  = { foo: 'bar', one: 1, two: 2 }
+    adapter_class = Adalog::MockLoggingAdapter.new('SomeService', default_repo, **stub_methods)
+    adapter       = adapter_class.new(foo: 'rofl')
+    assert_respond_to(adapter, :foo)
+    assert_equal('rofl', adapter.foo)
+  end
+
+
+  test "calls to stubs are stored in the repo" do
+    stub_methods  = { foo: 'bar', one: 1, two: 2 }
+    adapter_class = Adalog::MockLoggingAdapter.new('SomeService', default_repo, **stub_methods)
+    adapter       = adapter_class.new
+
+    adapter.foo('rofl', 'copter')
+    entry = default_repo.all.first
+    assert_equal("'foo', which has been stubbed with 'bar'.", entry.message)
+    assert_equal(['rofl', 'copter'], entry.details)
+    assert_equal('SomeService', entry.title)
+
+    adapter.one
+    entry = default_repo.all.first
+    assert_equal("'one', which has been stubbed with '1'.", entry.message)
+    assert_equal([], entry.details)
+    assert_equal('SomeService', entry.title)
+  end
+
+
+################################################################################
+
+
+  test "messages records stubbed method calls" do
+    adapter = build_tg_service_adapter
+    adapter.generate
+    adapter.toggle
+    message_names = adapter.messages.map(&:name)
+    assert_includes(message_names, :generate)
+    assert_includes(message_names, :toggle)
+  end
+
+
+  test "messages is an alias for _received_messages" do
+    adapter = build_tg_service_adapter
+    adapter.generate
+    adapter.toggle
+    assert_equal(adapter.messages, adapter._received_messages)
+  end
+
+
+  test "elements in messages record args" do
+    adapter = build_tg_service_adapter
+    adapter.generate(1, 'two', :three, 4, foo: :bar) { |can_do| "a thing" }
+    assert_equal([1, 'two', :three, 4], adapter.messages.first.args)
+  end
+
+
+  test "elements in messages record kwargs" do
+    adapter = build_tg_service_adapter
+    adapter.generate(1, 2, 3, foo: :bar, baz: ['bim']) { |can_do| "a thing" }
+    assert_equal({ foo: :bar, baz: ['bim'] }, adapter.messages.first.kwargs)
+  end
+
+
+  test "elements in messages record blocks" do
+    adapter = build_tg_service_adapter
+    sent_block = Proc.new { |can_do| "a thing" }
+    adapter.generate(1, 2, 3, foo: :bar, &sent_block)
+    assert_equal(sent_block, adapter.messages.first.block)
+  end
+
+
+  test "elements in messages have a summary arguments method" do
+    adapter = build_tg_service_adapter
+    sent_block = Proc.new { |can_do| "a thing" }
+    adapter.generate(1, 2, 3, foo: :bar, &sent_block)
+    assert_equal([1, 2, 3, { foo: :bar }], adapter.messages.first.arguments)
+  end
+
+
+  test "stubs call the blocks passed" do
+    canary = "alive"
+    adapter = build_tg_service_adapter
+    adapter.generate(1, 2, 3, foo: :bar) { canary = "dead" }
+    assert_equal("dead", canary)
+  end
+
+
+  test "can be asked if messages are received at least n times" do
+    adapter = build_tg_service_adapter
+    assert(adapter.received?(:toggle,   at_least: 0))
+    refute(adapter.received?(:toggle,   at_least: 1))
+    assert(adapter.received?(:generate, at_least: 0))
+    refute(adapter.received?(:generate, at_least: 1))
+
+    adapter.generate
+    assert(adapter.received?(:toggle,   at_least: 0))
+    refute(adapter.received?(:toggle,   at_least: 1))
+    assert(adapter.received?(:generate, at_least: 0))
+    assert(adapter.received?(:generate, at_least: 1))
+    refute(adapter.received?(:generate, at_least: 2))
+
+    adapter.generate
+    assert(adapter.received?(:toggle,   at_least: 0))
+    refute(adapter.received?(:toggle,   at_least: 1))
+    assert(adapter.received?(:generate, at_least: 0))
+    assert(adapter.received?(:generate, at_least: 1))
+    assert(adapter.received?(:generate, at_least: 2))
+    refute(adapter.received?(:generate, at_least: 3))
+
+    adapter.toggle
+    assert(adapter.received?(:toggle,   at_least: 0))
+    assert(adapter.received?(:toggle,   at_least: 1))
+    refute(adapter.received?(:toggle,   at_least: 2))
+    assert(adapter.received?(:generate, at_least: 0))
+    assert(adapter.received?(:generate, at_least: 1))
+    assert(adapter.received?(:generate, at_least: 2))
+    refute(adapter.received?(:generate, at_least: 3))
+  end
+
+
+  test "can be asked if messages are received at most n times" do
+    adapter = build_tg_service_adapter
+    assert(adapter.received?(:toggle,   at_most: 0))
+    assert(adapter.received?(:generate, at_most: 0))
+
+    adapter.generate
+    assert(adapter.received?(:toggle,   at_most: 0))
+    assert(adapter.received?(:generate, at_most: 1))
+    refute(adapter.received?(:generate, at_most: 0))
+
+    adapter.generate
+    assert(adapter.received?(:toggle,   at_most: 0))
+    assert(adapter.received?(:generate, at_most: 2))
+    refute(adapter.received?(:generate, at_most: 1))
+    refute(adapter.received?(:generate, at_most: 0))
+
+    adapter.toggle
+    assert(adapter.received?(:toggle,   at_most: 1))
+    refute(adapter.received?(:toggle,   at_most: 0))
+    assert(adapter.received?(:generate, at_most: 2))
+    refute(adapter.received?(:generate, at_most: 1))
+    refute(adapter.received?(:generate, at_most: 0))
+  end
+
+
+  test "can be asked if messages are received exactly n times" do
+    adapter = build_tg_service_adapter
+    assert(adapter.received?(:toggle,   exactly: 0))
+    assert(adapter.received?(:generate, exactly: 0))
+
+    adapter.generate
+    assert(adapter.received?(:toggle,   exactly: 0))
+    assert(adapter.received?(:generate, exactly: 1))
+    refute(adapter.received?(:generate, exactly: 2))
+
+    adapter.generate
+    assert(adapter.received?(:toggle,   exactly: 0))
+    assert(adapter.received?(:generate, exactly: 2))
+    refute(adapter.received?(:generate, exactly: 1))
+
+    adapter.toggle
+    assert(adapter.received?(:toggle,   exactly: 1))
+    assert(adapter.received?(:generate, exactly: 2))
+  end
+
+
+  test "can be asked if messages are received amount within bounds" do
+    adapter = build_tg_service_adapter
+    assert(adapter.received?(:generate, at_least: 0, at_most: 0))
+
+    adapter.generate
+    refute(adapter.received?(:generate, at_least: 0, at_most: 0))
+    assert(adapter.received?(:generate, at_least: 0, at_most: 1))
+    assert(adapter.received?(:generate, at_least: 1, at_most: 1))
+    # Test even an invalid range:
+    refute(adapter.received?(:generate, at_least: 1, at_most: 0))
+
+    adapter.generate
+    assert(adapter.received?(:generate, at_least: 0, at_most: 2))
+    assert(adapter.received?(:generate, at_least: 1, at_most: 2))
+    assert(adapter.received?(:generate, at_least: 2, at_most: 2))
+    # Test even an invalid range:
+    refute(adapter.received?(:generate, at_least: 3, at_most: 2))
+  end
+
+
+  test "when asked if messages are received, defaults to at least once" do
+    adapter = build_tg_service_adapter
+    assert_equal_to_at_least_once = ->() {
+      assert_equal(
+        adapter.received?(:generate),
+        adapter.received?(:generate, at_least: 1)
+      )
+    }
+    # For zero calls
+    assert_equal_to_at_least_once.call
+    # One call case
+    adapter.generate
+    assert_equal_to_at_least_once
+    # More-than-one call case
+    adapter.generate
+    assert_equal_to_at_least_once
+  end
+
+
+end
+
+# flips = ->(a) { [!a, flips] }

data/test/unit/simple_logging_adapter_test.rb

@@ -0,0 +1,66 @@
+require 'test_helper'
+
+class SimpleLoggingAdapterTest < Minitest::Test
+
+  def setup
+    @default_repo = Adalog::InMemoryRepo.new
+  end
+
+
+  def default_repo
+    @default_repo ||= Adalog::InMemoryRepo.new
+  end
+
+
+################################################################################
+
+
+  test "new creates a logging adapter class" do
+    adapter_class = Adalog::SimpleLoggingAdapter.new('SomeService', default_repo)
+    assert_kind_of(Class, adapter_class)
+  end
+
+
+  test "class accessors for service_name and repo" do
+    adapter_class = Adalog::SimpleLoggingAdapter.new('SomeService', default_repo)
+    assert_respond_to(adapter_class, :service_name)
+    assert_respond_to(adapter_class, :repo)
+    adapter = adapter_class.new
+    assert_equal('SomeService', adapter.service_name)
+    assert_equal(default_repo, adapter.repo)
+  end
+
+
+  test "all messages sent are stored as entries with message as message attribute" do
+    adapter_class = Adalog::SimpleLoggingAdapter.new('SomeService', default_repo)
+    adapter       = adapter_class.new
+    adapter.some
+    adapter.call
+    adapter.method_names("with", :arguments)
+    repo_contents = default_repo.all
+    assert(!!repo_contents.find { |entry| :some == entry.message })
+    assert(!!repo_contents.find { |entry| :call == entry.message })
+    assert(!!repo_contents.find { |entry| :method_names == entry.message })
+  end
+
+
+  test "message arguments are stored in the details section of an entry" do
+    adapter_class = Adalog::SimpleLoggingAdapter.new('OtherServiceName', default_repo)
+    adapter       = adapter_class.new
+    adapter.capture_a_method_name("with", :arguments)
+    entry = default_repo.all.first
+    assert(!!entry)
+    assert_equal(["with", :arguments], entry.details)
+  end
+
+
+  test "the service name is used as the entry title" do
+    adapter_class = Adalog::SimpleLoggingAdapter.new('OtherServiceName', default_repo)
+    adapter       = adapter_class.new
+    adapter.capture_a_method_name("with", :arguments)
+    entry = default_repo.all.first
+    assert(!!entry)
+    assert_equal('OtherServiceName', entry.title)
+  end
+
+end

data/test/unit/stub_logging_adapter_test.rb

@@ -0,0 +1,90 @@
+require 'test_helper'
+
+class StubLoggingAdapterTest < Minitest::Test
+
+  def setup
+    @default_repo = Adalog::InMemoryRepo.new
+  end
+
+
+  def default_repo
+    @default_repo ||= Adalog::InMemoryRepo.new
+  end
+
+
+################################################################################
+
+
+  test "new creates a logging adapter class" do
+    adapter_class = Adalog::StubLoggingAdapter.new('SomeService', default_repo)
+    assert_kind_of(Class, adapter_class)
+  end
+
+
+  test "class accessors for service_name and repo" do
+    adapter_class = Adalog::StubLoggingAdapter.new('SomeService', default_repo)
+    assert_respond_to(adapter_class, :service_name)
+    assert_respond_to(adapter_class, :repo)
+    adapter = adapter_class.new
+    assert_equal('SomeService', adapter.service_name)
+    assert_equal(default_repo, adapter.repo)
+  end
+
+
+  test "instance methods are created for stubs specified in new" do
+    stub_methods  = { foo: 'bar', one: 1, two: 2 }
+    adapter_class = Adalog::StubLoggingAdapter.new('SomeService', default_repo, **stub_methods)
+    adapter       = adapter_class.new
+    assert_respond_to(adapter, :foo)
+    assert_respond_to(adapter, :one)
+    assert_respond_to(adapter, :two)
+  end
+
+
+  test "stubbed instance methods return provided stubbed values" do
+    stub_methods  = { foo: 'bar', one: 1, two: 2 }
+    adapter_class = Adalog::StubLoggingAdapter.new('SomeService', default_repo, **stub_methods)
+    adapter       = adapter_class.new
+    assert_equal('bar', adapter.foo)
+    assert_equal(1,     adapter.one)
+    assert_equal(2,     adapter.two)
+  end
+
+
+  test "new stubs can be added at instantiation" do
+    stub_methods  = { foo: 'bar', one: 1, two: 2 }
+    adapter_class = Adalog::StubLoggingAdapter.new('SomeService', default_repo, **stub_methods)
+    adapter       = adapter_class.new(baz: 'bim')
+    assert_respond_to(adapter, :baz)
+    assert_equal('bim', adapter.baz)
+  end
+
+
+  test "stubs can be overridden at instantiation" do
+    stub_methods  = { foo: 'bar', one: 1, two: 2 }
+    adapter_class = Adalog::StubLoggingAdapter.new('SomeService', default_repo, **stub_methods)
+    adapter       = adapter_class.new(foo: 'rofl')
+    assert_respond_to(adapter, :foo)
+    assert_equal('rofl', adapter.foo)
+  end
+
+
+  test "calls to stubs are stored in the repo" do
+    stub_methods  = { foo: 'bar', one: 1, two: 2 }
+    adapter_class = Adalog::StubLoggingAdapter.new('SomeService', default_repo, **stub_methods)
+    adapter       = adapter_class.new
+
+    adapter.foo('rofl', 'copter')
+    entry = default_repo.all.first
+    assert_equal("'foo', which has been stubbed with 'bar'.", entry.message)
+    assert_equal(['rofl', 'copter'], entry.details)
+    assert_equal('SomeService', entry.title)
+
+    adapter.one
+    entry = default_repo.all.first
+    assert_equal("'one', which has been stubbed with '1'.", entry.message)
+    assert_equal([], entry.details)
+    assert_equal('SomeService', entry.title)
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: adalog
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Paul Kwiatkowski
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-29 00:00:00.000000000 Z
+date: 2016-07-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sinatra
@@ -116,8 +116,10 @@ files:
 - lib/adalog/configuration.rb
 - lib/adalog/entry.rb
 - lib/adalog/in_memory_repo.rb
+- lib/adalog/mock_logging_adapter.rb
 - lib/adalog/pstore_repo.rb
 - lib/adalog/simple_logging_adapter.rb
+- lib/adalog/stub_logging_adapter.rb
 - lib/adalog/version.rb
 - lib/adalog/web.rb
 - lib/adalog/web/public/javascripts/adalog.js
@@ -139,7 +141,10 @@ files:
 - test/unit/configuration_test.rb
 - test/unit/entry_test.rb
 - test/unit/in_memory_repo_test.rb
+- test/unit/mock_logging_adapter_test.rb
 - test/unit/pstore_repo_test.rb
+- test/unit/simple_logging_adapter_test.rb
+- test/unit/stub_logging_adapter_test.rb
 homepage: https://github.com/swifthand/adalog
 licenses:
 - Revised BSD, see LICENSE.md
@@ -172,4 +177,7 @@ test_files:
 - test/unit/configuration_test.rb
 - test/unit/entry_test.rb
 - test/unit/in_memory_repo_test.rb
+- test/unit/mock_logging_adapter_test.rb
 - test/unit/pstore_repo_test.rb
+- test/unit/simple_logging_adapter_test.rb
+- test/unit/stub_logging_adapter_test.rb