mongoid-casino 0.0.1

data/spec/lib/casino/intersection/match/equivalence_spec.rb

@@ -0,0 +1,26 @@
+describe Casino::Intersection::Match::Equivalence do
+
+  let(:klass) { Casino::Intersection::Match::Equivalence }
+  let(:source) { "Facebook" }
+  let(:document) { Model.new(source: source) }
+  let(:criteria) { Model.where(source: source) }
+  let(:selector) { criteria.selector }
+  let(:key) { 'source' }
+  let(:field) { selector[key] }
+  let(:value) { document.send(key) }
+  let(:equivalence) { klass.new(key, field, document, source) }
+
+  describe '#evaluate' do
+    describe 'when values match' do
+      subject { equivalence.evaluate }
+      it { subject.must_equal true }
+    end
+
+    describe 'when values do not match' do
+      let(:inequivalence) { klass.new(key, field, document, "Google") }
+      subject { inequivalence.evaluate }
+      it { subject.must_equal false }
+    end
+  end
+
+end

data/spec/lib/casino/intersection/match/expression_spec.rb

@@ -0,0 +1,26 @@
+describe Casino::Intersection::Match::Expression do
+
+  let(:klass) { Casino::Intersection::Match::Expression }
+  let(:source) { "Facebook" }
+  let(:document) { Model.new(source: source) }
+  let(:criteria) { Model.where(source: /facebook/i) }
+  let(:selector) { criteria.selector }
+  let(:key) { 'source' }
+  let(:field) { selector[key] }
+  let(:value) { document.send(key) }
+  let(:equivalence) { klass.new(key, field, document, source) }
+
+  describe '#evaluate' do
+    describe 'when values match' do
+      subject { equivalence.evaluate }
+      it { subject.must_equal true }
+    end
+
+    describe 'when values do not match' do
+      let(:inequivalence) { klass.new(key, field, document, "Google") }
+      subject { inequivalence.evaluate }
+      it { subject.must_equal false }
+    end
+  end
+
+end

data/spec/lib/casino/intersection/match/greater_spec.rb

@@ -0,0 +1,72 @@
+describe Casino::Intersection::Match::Greater do
+
+  let(:system) { Casino::Intersection::Match::Greater }
+
+  describe 'greater than' do
+
+    describe '#eligible?' do
+      describe "when the key is $gt" do
+        let(:matcher) { system.new '$gt', '', '', '' }
+        subject { matcher.eligible? }
+      end
+    end
+
+    describe '#evaluate' do
+
+      describe 'when the value is greater than the field' do
+        it "returns true" do
+          matcher = system.new '$gt', Date.today, '', Date.yesterday
+          matcher.evaluate.must_equal true
+        end
+      end
+
+      describe 'when the value is less than the field' do
+        it "returns false" do
+          matcher = system.new '$gt', Date.yesterday, '', Date.today
+          matcher.evaluate.must_equal false
+        end
+      end
+
+    end
+
+  end
+
+  describe 'greater than or equal to' do
+
+    describe '#eligible?' do
+      describe "when the key is $gt" do
+        it "returns true" do
+          matcher = system.new '$gte', '', '', ''
+          matcher.eligible?.must_equal true
+        end
+      end
+    end
+
+    describe '#evaluate' do
+
+      describe 'when the value is greater than the field' do
+        it "returns true" do
+          matcher = system.new '$gte', Date.today, '', Date.yesterday
+          matcher.evaluate.must_equal true
+        end
+      end
+
+      describe 'when the value is equal to the field' do
+        it "returns true" do
+          matcher = system.new '$gte', Date.yesterday, '', Date.yesterday
+          matcher.evaluate.must_equal true
+        end
+      end
+
+      describe 'when the value is less than the field' do
+        it "returns false" do
+          matcher = system.new '$gte', Date.yesterday, '', Date.today
+          matcher.evaluate.must_equal false
+        end
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/casino/intersection/match/include_spec.rb

@@ -0,0 +1,27 @@
+describe Casino::Intersection::Match::Include do
+
+  let(:system) { Casino::Intersection::Match::Include }
+
+  describe '#eligible?' do
+    describe 'when the key is $in' do
+      let(:matcher) { system.new('$in', '', '', '') }
+      subject { matcher.eligible? }
+      it { subject.must_equal true }
+    end
+  end
+
+  describe '#evaluate' do
+    describe 'when the value is within the field' do
+      let(:matcher) { system.new('$in', 1, '', [1, 2, 3, 4]) }
+      subject { matcher.evaluate }
+      it { subject.must_equal true }
+    end
+
+    describe 'when the value is not within the field' do
+      let(:matcher) { system.new('$in', 1, '', [2, 3, 4]) }
+      subject { matcher.evaluate }
+      it { subject.must_equal false }
+    end
+  end
+
+end

data/spec/lib/casino/intersection/match/lesser_spec.rb

@@ -0,0 +1,74 @@
+describe Casino::Intersection::Match::Lesser do
+
+  let(:system) { Casino::Intersection::Match::Lesser }
+
+  describe 'lesser than' do
+
+    describe '#eligible?' do
+      describe "when the key is $lt" do
+        it "returns true" do
+          matcher = system.new '$lt', '', '', ''
+          matcher.eligible?.must_equal true
+        end
+      end
+    end
+
+    describe '#evaluate' do
+
+      describe 'when the value is less than the field' do
+        it "returns true" do
+          matcher = system.new '$lt', Date.yesterday, '', Date.today
+          matcher.evaluate.must_equal true
+        end
+      end
+
+      describe 'when the value is greater than the field' do
+        it "returns false" do
+          matcher = system.new '$lt', Date.today, '', Date.yesterday
+          matcher.evaluate.must_equal false
+        end
+      end
+
+    end
+
+  end
+
+  describe 'lesser than or equal to' do
+
+    describe '#eligible?' do
+      describe "when the key is $lte" do
+        it "returns true" do
+          matcher = system.new '$lte', '', '', ''
+          matcher.eligible?.must_equal true
+        end
+      end
+    end
+
+    describe '#evaluate' do
+
+      describe 'when the value is less than the field' do
+        it "returns true" do
+          matcher = system.new '$lte', Date.yesterday, '', Date.today
+          matcher.evaluate.must_equal true
+        end
+      end
+
+      describe 'when the value is equal to the field' do
+        it "returns true" do
+          matcher = system.new '$lte', Date.today, '', Date.today
+          matcher.evaluate.must_equal true
+        end
+      end
+
+      describe 'when the value is greater than the field' do
+        it "returns false" do
+          matcher = system.new '$lte', Date.today, '', Date.yesterday
+          matcher.evaluate.must_equal false
+        end
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/casino/intersection/match/recurse_spec.rb

@@ -0,0 +1,24 @@
+describe Casino::Intersection::Match::Recurse do
+
+  let(:system) { Casino::Intersection::Match::Recurse }
+
+  describe '#eligible?' do
+    let(:matcher) { system.new('', '', '', {}) }
+    subject { matcher.eligible? }
+    it { subject.must_equal true }
+  end
+
+  describe '#evaluate' do
+
+    let(:matcher) { system.new('', '', '', { '$gt' => 4 }) }
+    let(:base) { Casino::Intersection::Match::Base }
+    subject { matcher.evaluate }
+    it 'builds base matchers to evaluate' do
+      base.stub(:new, OpenStruct.new(evaluate: true)) do
+        subject.must_equal true
+      end
+    end
+
+  end
+
+end

data/spec/lib/casino/intersection_spec.rb

@@ -0,0 +1,33 @@
+describe Casino::Intersection do
+
+  let(:label) { [ Date.today.strftime("%m/%d/%Y"), "Facebook" ] }
+  let(:criteria) { Model.scoped }
+  let(:intersection) { Casino::Intersection.new(label, criteria) }
+
+  subject { intersection }
+
+  it { subject.label.must_equal label }
+  it { subject.criteria.must_equal criteria }
+  it { subject.must_respond_to :selector }
+
+  describe '#match?' do
+
+    let(:model) { Model.new }
+    let(:criteria) { Model.where(created_at: Date.today) }
+    let(:intersection) { Casino::Intersection.new(label, criteria) }
+    let(:value) { model.created_at }
+    let(:base_class) { Casino::Intersection::Match::Base }
+    let(:base_mock) { MiniTest::Mock.new }
+    let(:base_instance) { base_class.new(*base_arguments) }
+    let(:base_arguments) { [model, 'created_at', intersection.selector, value] }
+
+    it "invokes a Casino::Intersection::Match::Base instance" do
+      base_mock.expect(:evaluate, base_instance)
+      base_class.stub(:new, base_mock) do
+        intersection.match?(model)
+      end
+      base_mock.verify
+    end
+  end
+
+end

data/spec/lib/casino/lobby_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Casino::Lobby do
+
+  let(:collection) { Collection }
+  let(:object_class) { Model }
+  let(:object_instance) { object_class.new }
+  let(:object_key) { object_class.name.downcase.split("::").last.to_sym }
+  let(:lobby) { Casino::Lobby.new(collection) }
+
+  subject { lobby }
+
+  it { subject.collection.must_equal collection }
+
+  it "stores objects instances in a registry" do
+    subject.add_registry(object_instance)
+    subject.registry[object_key].must_include object_instance
+  end
+
+end

data/spec/lib/casino/projection_spec.rb

@@ -0,0 +1,81 @@
+describe Casino::Projection do
+
+  let(:projection) { Casino::Projection.new(Model) }
+
+  describe '#results' do
+    it "sends the pipeline to the collection's aggregate method" do
+      Model.collection.stub(:aggregate, []) do
+        projection.results.must_equal []
+      end
+    end
+  end
+
+  describe '#mongoize' do
+    let(:hash) do
+      { group: { '_id' => :email, 'count' => { sum: 1 } } }
+    end
+    let(:mongoized_hash) do
+      { '$group' => { '_id' => '$email', 'count' => { '$sum' => 1 } } }
+    end
+    subject { projection.mongoize(hash) }
+    it { subject.must_equal mongoized_hash }
+  end
+
+  describe '#group' do
+    let(:group_hash) do
+      { '$group'  => { '_id' => '$author' } }
+    end
+    subject { projection.group('_id' => :author) }
+    it { subject.pipeline.must_include group_hash }
+  end
+
+  describe '#project' do
+    let(:project_hash) do
+      { '$project'  => { 'person' => '$human' } }
+    end
+    subject { projection.project('person' => :human) }
+    it { subject.pipeline.must_include project_hash }
+  end
+
+  describe '#unwind' do
+    let(:unwind_hash) do
+      { '$unwind' => '$notes' }
+    end
+    subject { projection.unwind(:notes) }
+    it { subject.pipeline.must_include unwind_hash }
+  end
+
+  describe '#match' do
+    let(:today) { Date.today }
+    let(:match_hash) do
+      { '$match'  => { '$created_at' => { '$gte' => today } } }
+    end
+    subject { projection.match(created_at: { gte: today }) }
+    it { subject.pipeline.must_include match_hash }
+  end
+
+  describe '#sort' do
+    let(:sort_hash) do
+      { '$sort'  => { 'count' => -1 } }
+    end
+    subject { projection.sort('count' => -1) }
+    it { subject.pipeline.must_include sort_hash }
+  end
+
+  describe '#skip' do
+    let(:skip_hash) do
+      { '$skip'  => 10 }
+    end
+    subject { projection.skip(10) }
+    it { subject.pipeline.must_include skip_hash }
+  end
+
+  describe '#limit' do
+    let(:limit_hash) do
+      { '$limit'  => 10 }
+    end
+    subject { projection.limit(10) }
+    it { subject.pipeline.must_include limit_hash }
+  end
+
+end

data/spec/lib/casino/query_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Casino::Query do
+
+  let(:label) { "women's boots" }
+  let(:criteria) { [ /page_gender=f/i, /offer_cohort=boots/i ] }
+  let(:query) { Casino::Query.new(label, [], *criteria) }
+
+  subject { query }
+
+  it { subject.label.must_equal label }
+  it { subject.criteria.must_equal criteria }
+  it { subject.conditions.must_equal [] }
+
+  describe '#merge' do
+
+    let(:field) { :created_at }
+    let(:queries) { :method_name }
+    let(:and_approach) { { operator: :and } }
+
+    let(:dimension) do
+      Casino::Dimension.new("Date", field, queries, and_approach)
+    end
+
+    let(:conditions) do
+      query.criteria.map do |condition|
+        [ :and, { dimension.field => condition } ]
+      end
+    end
+
+    subject { query.merge(dimension) }
+
+    it "merges the dimension data in" do
+      subject.conditions.must_equal conditions
+    end
+
+    it "produces a different object" do
+      subject.wont_equal query
+    end
+
+  end
+end

data/spec/lib/casino/question_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe Casino::Question do
+  let(:name) { :emails }
+  let(:answer) { :distinct_emails }
+  let(:question) { Casino::Question.new(name, answer) }
+  subject { question }
+  it { subject.name.must_equal name }
+  it { subject.answer.must_equal answer }
+end