replay 0.0.1 → 0.1.0

data/proofs/replay/publisher_proof.rb

@@ -0,0 +1,170 @@
+require_relative "../proofs_init.rb"
+require 'replay/test'
+
+class ReplayTest
+  include Replay::Publisher
+  include Replay::EventExaminer
+
+  key :pkey
+
+  def initialize(pkey = 1)
+    @pkey = pkey
+  end
+
+  events do
+    SomeEvent(pid: Integer)
+    UnhandledEvent(pid: Integer)
+  end
+
+  apply SomeEvent do |event|
+    @event_count ||= 0
+    @event_applied = event.pid
+    @event_count += 1
+  end
+
+  def pkey
+    @pkey
+  end
+end
+
+module ReplayTest::Proof
+  def sets_publish_time
+    publish SomeEvent(pid: 123)
+    events.last.published_at != nil && (Time.now - events.last.published_at) < 20
+  end
+
+  def published_at_not_considered_in_equality
+    event = SomeEvent(pid: 123)
+    event == event.with(:published_at => Time.now-100)
+  end
+
+  def defines_events?
+    self.class.const_defined?(:SomeEvent) && self.class.const_get(:SomeEvent).is_a?(Class)
+  end
+  def adds_convenience_method?
+    respond_to? :SomeEvent
+  end
+  def applies_event?(event)
+    apply(event)
+    @event_applied == event.pid
+  end
+
+  def applies_events?(events)
+    apply(events)
+    @event_count == events.count
+  end
+
+  def throws_unhandled_event?(raise_it = true)
+    begin
+      apply(UnhandledEvent(pid: 123), raise_it)
+    rescue Replay::UnhandledEventError => e
+      true && raise_it
+    rescue Exception
+      !raise_it || false 
+    end
+  end
+
+  def can_publish_events?
+    event = SomeEvent(pid: 123)
+    publish(event)
+    events.detect{|e| e==event}
+  end
+
+  def subscribers_receive_events
+    sub = Class.new do
+      def published(stream, event)
+        @published = true
+      end
+      def published?; @published; end
+    end.new
+    add_subscriber(sub)
+    publish(ReplayTest::SomeEvent.new(pid: 123))
+    sub.published?
+  end
+  def subscribes()
+    sub = Class.new do
+      def published(stream, event)
+        @published = true
+      end
+      def published?; @published; end
+    end.new
+    add_subscriber(sub)
+    has_subscriber?(sub)
+  end
+end
+
+title "Publisher"
+
+proof "Defines events given in the events block" do
+  r = ReplayTest.new
+  r.prove{ defines_events? }
+end
+
+proof "Adds a convenience method for an event constructor to the class" do
+  r = ReplayTest.new
+  r.prove{ adds_convenience_method? }
+end
+
+proof "Applies events singly" do
+  r = ReplayTest.new
+  r.prove{ applies_event? ReplayTest::SomeEvent.new(:pid => 123)}
+end
+
+proof "Applies events in ordered batches" do
+  r = ReplayTest.new
+  r.prove do applies_events?([
+      ReplayTest::SomeEvent.new(:pid => 123), 
+      ReplayTest::SomeEvent.new(:pid => 234), 
+      ReplayTest::SomeEvent.new(:pid => 456)
+    ])
+  end
+end
+
+proof "Throws an UnhandledEventError for unhandled events" do
+  r = ReplayTest.new
+  r.prove{ throws_unhandled_event? }
+end
+
+proof "Ignores unhandled events if requested" do
+  r = ReplayTest.new
+  r.prove{ throws_unhandled_event? false}
+end
+
+proof "Can publish events to the indicated stream" do
+  r = ReplayTest.new
+  r.prove { can_publish_events? }
+end
+
+proof "Subscriber can subscribe to events from publisher" do
+  r = ReplayTest.new
+  r.prove{ subscribes }
+end
+
+proof "Subscriber receives published events" do
+  r = ReplayTest.new
+  r.prove{ subscribers_receive_events }
+end
+
+proof "Returns self from apply" do
+  r = ReplayTest.new
+  r.prove{ apply([]) == self}
+end
+proof "Returns self from publish" do
+  r = ReplayTest.new
+  r.prove{ publish([]) == self}
+end
+
+proof "sets the publish time on events" do
+  r = ReplayTest.new
+  r.prove{ sets_publish_time }
+end
+
+proof "publish time is not part of equality" do
+  r = ReplayTest.new
+  r.prove{ published_at_not_considered_in_equality}
+end
+
+proof "Can implement initializer with arguments" do
+  r = ReplayTest.new(:foo)
+  r.prove { pkey == :foo }
+end

data/proofs/replay/repository_configuration_proof.rb

@@ -0,0 +1,67 @@
+require_relative "../proofs_init.rb"
+require 'replay/test'
+
+class Subscriber
+  def published(stream_id, event); end
+end
+
+module Replay::Repository::Configuration::Proof
+  def can_configure_store?
+    self.store = :memory
+    self.store == Replay::Backends::MemoryStore
+  end
+
+  def can_add_default_subscriber?
+    sub = Subscriber.new
+    self.add_default_subscriber sub
+    subscribers.include? sub
+  end
+
+  def subscribers_include_store
+    self.store = :memory
+    self.subscribers.include? Replay::Backends::MemoryStore
+  end
+
+  def requires_store_to_act_like_subscriber
+    begin
+      store = Class.new do
+        def self.event_stream(stream); end
+      end
+      self.store = store
+    rescue Replay::InvalidSubscriberError => e
+      return true
+    rescue Exception  => e
+    end
+    false
+  end
+
+  def requires_store_to_load_events
+    begin
+      self.store = Subscriber.new 
+    rescue Replay::InvalidStorageError
+      return true
+    rescue Exception  => e
+    end
+    false
+  end
+end
+
+proof "can configure a store" do
+  Replay::Repository::Configuration.new.prove {can_configure_store?}
+end
+
+proof 'adding a store adds it as a subscriber' do
+  Replay::Repository::Configuration.new.prove { subscribers_include_store }
+end
+
+proof "can configure a default_subscriber" do
+  Replay::Repository::Configuration.new.prove {can_add_default_subscriber?}
+end
+
+proof "raises error if store won't load events" do
+  Replay::Repository::Configuration.new.prove {requires_store_to_load_events }
+end
+
+proof "raises error if store won't act like a subscriber" do
+  Replay::Repository::Configuration.new.prove {requires_store_to_act_like_subscriber }
+end

data/proofs/replay/repository_proof.rb

@@ -0,0 +1,46 @@
+require_relative "../proofs_init.rb"
+require 'replay/test'
+
+class Subscriber
+  def published(stream_id, event); end
+end
+
+class RepositoryTest
+  include Replay::Repository
+  include Singleton
+
+  class << self
+    attr_accessor :proven
+  end
+
+  def self.can_be_configured
+    self.configure do |config|
+      self.proven = true
+    end
+
+    self.proven
+  end
+end
+
+title "Repository interface"
+
+proof "repository can be configured" do
+  RepositoryTest.prove {can_be_configured }
+end
+
+Proof::Output.class_exec do 
+  writer :pending, :level => :info do |text|
+    prefix :pending, "PENDING: #{text}"
+  end
+end
+
+def pending(text = "pending test")
+  Proof::Output.pending "pending test"
+end
+proof "loads an instance of supplied class" do; pending; end
+proof "load raises an error if event stream isn't found" do; pending; end
+proof "load returns uncreated instance when :create is pending" do; false; end
+proof "load returns a created instance when :create is true" do; pending; end
+
+proof "reload returns the supplied instance in its current state" do; pending; end
+

data/proofs/replay/subscriber_manager_proof.rb

@@ -0,0 +1,39 @@
+require_relative "../proofs_init.rb"
+require 'replay/test'
+
+module Replay::SubscriptionManager::Proof
+  def only_adds_legit_subs
+    begin
+      add_subscriber(Object.new)
+    rescue Replay::InvalidSubscriberError => e
+      return true
+    end
+    false
+  end
+
+  def sub_gets_notified
+    sub = Class.new do
+      attr_accessor :stream, :event
+      def published(stream, event)
+        self.stream = stream
+        self.event = event
+      end
+    end.new
+    add_subscriber(sub)
+    notify_subscribers "123", "456"
+    sub.stream == '123' && sub.event == '456'
+  end
+end
+
+title "Subscription Manager"
+
+proof "raises InvalidSubscriberError when subscriber fails to implement #published" do
+  sm = Replay::SubscriptionManager.new
+  sm.prove { only_adds_legit_subs }
+end
+
+proof "notifies proper subscriber when informed" do
+  sm = Replay::SubscriptionManager.new
+  sm.prove { sub_gets_notified }
+end
+

data/proofs/replay/test_proof.rb

@@ -0,0 +1,28 @@
+require_relative "../proofs_init.rb"
+require 'replay/test'
+
+desc "proof for the test support provided by replay"
+
+title "Test support"
+
+proof "fuzzy matching of events" do
+  class TestEvent
+    include Replay::EventDecorator
+    
+    values do
+      attribute :one, String
+      attribute :two, String
+    end
+
+    def matches_fuzzy(event)
+      self.kind_of_matches?(event)
+    end
+  end
+
+  e1 = TestEvent.new(one: '1')
+  e2 = TestEvent.new(one: '1', two: '2')
+
+  e1.prove{ matches_fuzzy(e2)}
+  e2.prove{ !matches_fuzzy(e1)}
+
+end

data/replay.gemspec

@@ -19,8 +19,9 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
 
   # specify any dependencies here; for example:
-  s.add_development_dependency "activerecord"
-  s.add_development_dependency "sqlite3-ruby"
-  # s.add_runtime_dependency "rest-client"
-  s.add_runtime_dependency "activesupport"
+  s.add_development_dependency "bundler", "~>1.3"
+  s.add_development_dependency "rake"
+  s.add_development_dependency "minitest"
+  #s.add_runtime_dependency "rest-client"
+  s.add_runtime_dependency "virtus", "~>1.0.0"
 end

data/test/replay/observer_spec.rb

@@ -0,0 +1,37 @@
+require 'test_helper'
+
+class ObservedEvent
+end
+
+class UnobservedEvent
+end
+
+class ObserverTest
+  include Replay::Observer
+  observe ObservedEvent do |stream, event|
+    @observed = true
+  end
+
+  def self.observed?
+    @observed
+  end
+
+  def self.reset
+    @observed=false
+  end
+end
+
+describe Replay::Observer do
+  before do
+    ObserverTest.reset
+  end
+  it "calls the observer block for observed events" do
+    ObserverTest.published('123', ObservedEvent.new)
+    ObserverTest.must_be :observed?
+  end
+
+  it "does not notify of unobserved events" do
+    ObserverTest.published('123', UnobservedEvent.new)
+    ObserverTest.wont_be :observed?
+  end
+end

data/test/replay/router/default_router_spec.rb

@@ -0,0 +1,43 @@
+require 'test_helper'
+
+module Router
+  module Test
+    def has_observer?(object)
+      @subscription_manager.has_subscriber?(object)
+    end
+  end
+end
+class TypedEvent
+
+end
+class Observer
+  def self.published(stream, event)
+    @typed=true
+  end
+
+  def self.typed_received?
+    @typed
+  end
+end
+
+Replay::Router::DefaultRouter.send(:include, Router::Test)
+
+describe Replay::Router::DefaultRouter do
+  before do
+    @router = Replay::Router::DefaultRouter.instance
+  end
+  describe "adding observers" do
+    it "tracks the observing object" do
+      @router.add_observer(Observer)
+      assert(@router.has_observer?(Observer), "router does not track observer")
+    end
+  end
+  describe "event publishing" do
+    it "tells the observing object about events being published" do
+      @router.add_observer(Observer)
+      @router.published("123", TypedEvent.new)
+      assert Observer.typed_received?, "Did not receive notification of event"
+    end
+  end
+end
+