sandthorn_event_filter 0.0.1

data/spec/filter_spec.rb

@@ -0,0 +1,151 @@
+require 'spec_helper'
+
+module SandthornEventFilter
+  describe Filter do
+    let(:fake_events) { [:event, :other_event] }
+    let(:filter) { Filter.new(fake_events) }
+
+    describe "basic methods" do
+      it "should respond to basic methods" do
+        methods = [:each, :first, :last, :length, :empty?, :reject, :[]]
+        methods.each do |method|
+          expect(filter).to respond_to(method)
+        end
+      end
+    end
+
+    describe ".initialize" do
+
+      it "is possible to create an empty filter" do
+        expect { Filter.new }.to_not raise_error
+      end
+
+      it "exposes the original events" do
+        expect(filter.original_events).to eq(fake_events)
+      end
+
+      it "has a filter chain" do
+        expect(filter.matchers).to_not be_nil
+      end
+    end
+
+    describe ".events" do
+      context "when there are no matchers" do
+        it "should return the original events" do
+          expect(filter.events).to eq(fake_events)
+        end
+      end
+
+      context "when there is a filter" do
+        let(:events) { [{ aggregate_type: "Foo" }, { aggregate_type: "Bar" }] }
+        it "should return the filtered result" do
+          filter = Filter.new(events).extract(types: "Foo")
+          filtered_events = filter.events
+          expect(filtered_events.length).to eq(1)
+          expect(filtered_events).to include(events.first)
+        end
+      end
+    end
+
+    describe ".apply" do
+      let(:events) { [{ aggregate_type: "Foo" }, { aggregate_type: "Bar" }] }
+      it "should return the filtered result" do
+        filter = Filter.new.extract(types: "Foo")
+        filtered_events = filter.apply(events)
+        expect(filtered_events.length).to eq(1)
+        expect(filtered_events).to include(events.first)
+      end
+    end
+
+    describe "chaining" do
+      let(:events) { [{aggregate_type: "Foo"}, {aggregate_type: "Bar"}] }
+      context "when chaining filters" do
+        it "should leave the original filter untouched" do
+          filter = Filter.new(events)
+          other_filter = filter.extract(types: "Foo")
+          expect(filter.events).to eq(events)
+        end
+
+        describe "the new filter" do
+          it "should be a new filter instance" do
+            filter = Filter.new(events)
+            other_filter = filter.extract(types: "Foo")
+            expect(other_filter).to_not equal(filter)
+          end
+
+          it "should have the same original events" do
+            filter = Filter.new(events)
+            other_filter = filter.extract(types: "Foo")
+            expect(other_filter.original_events).to eq(filter.original_events)
+          end
+        end
+      end
+    end
+
+    describe ".select and .reject" do
+      let(:events) { [{aggregate_type: "Foo"}, {aggregate_type: "Bar"}] }
+      it "should return a new filter" do
+        filter = Filter.new(events)
+        reject = filter.select { |e| e[:aggregate_type] == "Foo" }
+        select = filter.reject { |e| e[:aggregate_type] == "Bar" }
+        expect(reject).to be_kind_of Filter
+        expect(select).to be_kind_of Filter
+        expect(select.events).to eq([events.first])
+        expect(reject.events).to eq([events.first])
+      end
+    end
+
+  end
+
+  describe 'tests on actual data' do
+    let(:events) { SandthornEventFilter::Fixtures::EVENTS }
+
+    context 'when extracting `new` events' do
+      it "should return matching events" do
+        new_events_filter = Filter.new(events).extract(events: "new")
+        expect(new_events_filter.length).to eq(2)
+        event = Event.wrap(new_events_filter.first)
+        expect(event.name).to eq("new")
+      end
+    end
+
+    context 'when removing `new` events' do
+      it "should return matching events" do
+        filter = Filter.new(events).remove(events: 'new')
+        filtered = filter.events
+        expect(filtered.length).to eq(18)
+      end
+    end
+
+    context 'when extracting events for an aggregate type' do
+      it "should return only matching events" do
+        filter = Filter.new(events).extract(types: 'SandthornTest')
+        filtered = filter.events
+        expect(filtered.length).to eq(1)
+        expect(Event.wrap(filtered.first).aggregate_type).to eq("SandthornTest")
+      end
+    end
+
+    context 'when removing events for an aggregate type' do
+      it "should return matching events" do
+        filter = Filter.new(events).remove(types: 'SandthornTest')
+        filtered = filter.events
+        expect(filtered.length).to eq(19)
+        expect(filtered).to all( have_aggregate_type 'SandthornProduct' )
+      end
+    end
+
+    context "when extracting events with a changed attribute" do
+      it "should return matching events" do
+        filter = Filter.new(events).extract(changed_attributes: "name")
+        filtered = filter.events
+        expect(filtered.length).to eq(11)
+        filtered.each do |event|
+          expect(Event.wrap(event).attribute_deltas.any? {|delta| delta[:attribute_name] == "name" }).to be_truthy
+        end
+      end
+    end
+
+  end
+
+end

data/spec/matchers/attribute_changed_matcher_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+module SandthornEventFilter
+  module Matchers
+    describe AttributeChangedMatcher do
+      let(:event) do
+        {
+            aggregate_id:"555dc484-5727-44b1-a8da-0f85014d7204",
+            aggregate_type: "ProductAggregates::Store",
+            aggregate_version: 1,
+            timestamp: Time.parse("2014-08-05 16:00:40.107738"),
+            sequence_number: 3,
+            event_name: "new",
+            event_args: {
+              attribute_deltas: [
+                  {
+                      attribute_name: "name",
+                      new_value: nil,
+                      old_value: nil
+                  },
+                  {
+                      attribute_name: "description",
+                      new_value: nil,
+                      old_value: nil
+                  }
+              ]
+            }
+        }
+      end
+
+      describe ".match?" do
+        context "when given a changed attributes" do
+          it "should return true" do
+            matcher = AttributeChangedMatcher.new("name")
+            expect(matcher.match?(event)).to be_truthy
+          end
+        end
+
+        context "when given a non-changed attribute" do
+          it "should return false" do
+            matcher = AttributeChangedMatcher.new("foo")
+            expect(matcher.match?(event)).to be_falsey
+          end
+        end
+      end
+    end
+  end
+end

data/spec/matchers/block_matcher_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+module SandthornEventFilter
+  module Matchers
+    describe BlockMatcher do
+      context "when the given block evaluates to true" do
+        it "should match" do
+          matcher = BlockMatcher.new do |event|
+            true
+          end
+          expect(matcher.match?({})).to be_truthy
+        end
+      end
+
+      context "when the given block evaluates to false" do
+        it "shouldn't match" do
+          matcher = BlockMatcher.new do |event|
+            false
+          end
+          expect(matcher.match?({})).to be_falsey
+        end
+      end
+
+    end
+  end
+end

data/spec/matchers/class_matcher_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+module SandthornEventFilter
+  module Matchers
+    describe AggregateTypeMatcher do
+      let(:foo_event) { { aggregate_type: "Foo"} }
+      let(:bar_event) { { aggregate_type: "Bar"} }
+
+      describe ".match?" do
+        context "when given one class" do
+          context "and given an event of that class" do
+            it "should return true" do
+              filter = AggregateTypeMatcher.new("Foo")
+              expect(filter.match?(foo_event)).to be_truthy
+            end
+          end
+
+          context "when given a non-matching event" do
+            it "should return false" do
+              filter = AggregateTypeMatcher.new("Foo")
+              expect(filter.match?(bar_event)).to be_falsey
+            end
+          end
+        end
+
+        context "when given multiple types" do
+          it "should return true if event matches any of the input types" do
+            filter = AggregateTypeMatcher.new(["Bar", "Foo"])
+            expect(filter.match?(foo_event)).to be_truthy
+            expect(filter.match?(bar_event)).to be_truthy
+          end
+        end
+      end
+
+    end
+  end
+end

data/spec/matchers/event_name_matcher_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+module SandthornEventFilter
+  module Matchers
+    describe EventNameMatcher do
+      let(:foo_event) { { event_name: "Foo"} }
+      let(:bar_event) { { event_name: "Bar"} }
+
+      describe ".match?" do
+        context "when given one event name" do
+          context "and given an event of that name" do
+            it "should return true" do
+              filter = EventNameMatcher.new("Foo")
+              expect(filter.match?(foo_event)).to be_truthy
+            end
+          end
+
+          context "when given a non-matching event" do
+            it "should return false" do
+              filter = EventNameMatcher.new("Foo")
+              expect(filter.match?(bar_event)).to be_falsey
+            end
+          end
+        end
+
+        context "when given multiple event names" do
+          it "should return true if event matches any of the input event names" do
+            filter = EventNameMatcher.new(["Bar", "Foo"])
+            expect(filter.match?(foo_event)).to be_truthy
+            expect(filter.match?(bar_event)).to be_truthy
+          end
+        end
+      end
+    end
+  end
+end

data/spec/matchers/extract_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+module SandthornEventFilter
+  module Matchers
+    describe Extract do
+      let(:foo_event) { { aggregate_type: "Foo", event_name: "foo" } }
+      let(:bar_event) { { aggregate_type: "Bar", event_name: "bar" } }
+
+      context "when given only class matchers" do
+        let(:foo_extractor) { Extract.new(types: "Foo") }
+
+
+        context "when given a matching event" do
+          it "should match" do
+            expect(foo_extractor.match?(foo_event)).to be_truthy
+          end
+        end
+
+        context "when given a non-matching event" do
+          it "shouldn't match" do
+            expect(foo_extractor.match?(bar_event)).to be_falsey
+          end
+        end
+      end
+
+      context "when given event_name matchers" do
+        let(:foo_extractor) { Extract.new(events: "foo") }
+
+        context "when given a matching event" do
+          it "should match" do
+            expect(foo_extractor.match?(foo_event)).to be_truthy
+          end
+        end
+
+        context "when given a non-matching event" do
+          it "should not match" do
+            expect(foo_extractor.match?(bar_event)).to be_falsey
+          end
+        end
+      end
+
+      context "when given combinations of matchers" do
+        let(:combo) { Extract.new(types: "Foo", events: "foo") }
+        context "when given an event that matches all of the criteria" do
+          it "should match" do
+            expect(combo.match?(foo_event)).to be_truthy
+          end
+        end
+
+        context "when given a partially matching event" do
+          it "should not match" do
+            event = { event_name: "foo", aggregate_type: "Baz" }
+            expect(combo.match?(event)).to be_falsey
+          end
+        end
+      end
+
+    end
+  end
+end

data/spec/matchers/matcher_collection_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+module SandthornEventFilter
+  module Matchers
+    describe MatcherCollection do
+
+      let(:events) { [:one, :two, :three] }
+      let(:chain) { SandthornEventFilter::Matchers::MatcherCollection.new }
+
+      describe ".add" do
+
+        let(:filter) { Object.new }
+
+        it 'returns a new chain' do
+          new_chain = chain.add(filter)
+          expect(new_chain).to be_kind_of MatcherCollection
+          expect(new_chain).to_not equal(chain)
+        end
+        it 'adds a filter to the chain' do
+          new_chain = chain.add(filter)
+          expect(new_chain.matchers).to include(filter)
+        end
+      end
+
+      describe ".apply" do
+        context "when there are no matchers in the chain" do
+          it "should return the original events" do
+            expect(chain.matchers).to be_empty
+            expect(chain.apply(events)).to eq(events)
+          end
+        end
+
+        context "when there are matchers" do
+          it "should call match? on the matchers for each event" do
+            filters = [IdentityMatcher.new, IdentityMatcher.new]
+            new_chain = chain.add(filters)
+            filters.each do |filter|
+              expect(filter).to receive(:match?).exactly(3).times.and_call_original
+            end
+            new_chain.apply(events)
+          end
+        end
+      end
+
+    end
+  end
+end

data/spec/matchers/sequence_number_matcher_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+module SandthornEventFilter
+  module Matchers
+    describe SequenceNumberMatcher do
+      let(:event) do
+        {
+          sequence_number: 1
+        }
+      end
+
+      context "when the event has a larger sequence number" do
+        it "should match" do
+          sequence_number = event[:sequence_number]
+          matcher = SequenceNumberMatcher.new(sequence_number - 1)
+          expect(matcher.match?(event)).to be_truthy
+        end
+      end
+
+      context "when the event has the same or lower sequence number" do
+        it "should not match" do
+          sequence_number = event[:sequence_number]
+          exact_matcher = SequenceNumberMatcher.new(sequence_number)
+          larger_matcher = SequenceNumberMatcher.new(sequence_number + 1)
+          expect(exact_matcher.match?(event)).to be_falsey
+          expect(larger_matcher.match?(event)).to be_falsey
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+require 'sandthorn_event_filter'
+require './spec/data/events'
+
+
+RSpec.configure do |config|
+end
+RSpec::Matchers.define :have_name do |expected|
+  match do |actual|
+    actual[:event_name] == expected
+  end
+end
+
+RSpec::Matchers.define :have_aggregate_type do |expected|
+  match do |actual|
+    actual[:aggregate_type] == expected
+  end
+end

metadata

@@ -0,0 +1,200 @@
+--- !ruby/object:Gem::Specification
+name: sandthorn_event_filter
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Jesper Josefsson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-08-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: gem-release
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: autotest-standalone
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: hamster
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- jesper.josefsson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/sandthorn_event_filter.rb
+- lib/sandthorn_event_filter/event.rb
+- lib/sandthorn_event_filter/filter.rb
+- lib/sandthorn_event_filter/matchers/aggregate_type_matcher.rb
+- lib/sandthorn_event_filter/matchers/attribute_changed_matcher.rb
+- lib/sandthorn_event_filter/matchers/block_matcher.rb
+- lib/sandthorn_event_filter/matchers/event_name_matcher.rb
+- lib/sandthorn_event_filter/matchers/extract.rb
+- lib/sandthorn_event_filter/matchers/identity_matcher.rb
+- lib/sandthorn_event_filter/matchers/matcher.rb
+- lib/sandthorn_event_filter/matchers/matcher_collection.rb
+- lib/sandthorn_event_filter/matchers/not_matcher.rb
+- lib/sandthorn_event_filter/matchers/sequence_number_matcher.rb
+- lib/sandthorn_event_filter/version.rb
+- sandthorn_event_filter.gemspec
+- spec/data/events.rb
+- spec/event_spec.rb
+- spec/filter_spec.rb
+- spec/matchers/attribute_changed_matcher_spec.rb
+- spec/matchers/block_matcher_spec.rb
+- spec/matchers/class_matcher_spec.rb
+- spec/matchers/event_name_matcher_spec.rb
+- spec/matchers/extract_spec.rb
+- spec/matchers/matcher_collection_spec.rb
+- spec/matchers/sequence_number_matcher_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/Sandthorn
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Composable filters for Sandthorn Events
+test_files:
+- spec/data/events.rb
+- spec/event_spec.rb
+- spec/filter_spec.rb
+- spec/matchers/attribute_changed_matcher_spec.rb
+- spec/matchers/block_matcher_spec.rb
+- spec/matchers/class_matcher_spec.rb
+- spec/matchers/event_name_matcher_spec.rb
+- spec/matchers/extract_spec.rb
+- spec/matchers/matcher_collection_spec.rb
+- spec/matchers/sequence_number_matcher_spec.rb
+- spec/spec_helper.rb