mongoid-casino 0.0.1

data/spec/fixtures/collections/collection.rb

@@ -0,0 +1,3 @@
+class Collection
+  include Casino::Collection
+end

data/spec/fixtures/collections/emails_by_day.rb

@@ -0,0 +1,28 @@
+class EmailsByDay < Collection
+
+  focus Model
+
+  dimension "Date", :created_at, :last_seven_days
+  dimension "Source", :source, :primary_sources
+
+  question :unique_emails, :count_emails
+
+  def last_seven_days
+    (7.days.ago.to_date..Date.today).map do |date|
+      key = date.strftime("%m/%d/%Y")
+      range = date.beginning_of_day
+      query(key, range)
+    end
+  end
+
+  def primary_sources
+    %w(Facebook Google Twitter).map do |source|
+      query(source, source)
+    end
+  end
+
+  def count_emails
+    intersection.distinct(:email).count
+  end
+
+end

data/spec/fixtures/models/model.rb

@@ -0,0 +1,8 @@
+class Model
+  include Mongoid::Document
+
+  field :created_at
+  field :source
+
+  embeds_many :notes
+end

data/spec/fixtures/models/note.rb

@@ -0,0 +1,7 @@
+class Note
+  include Mongoid::Document
+
+  field :views, type: Integer
+
+  embedded_in :model
+end

data/spec/lib/casino/collection_spec.rb

@@ -0,0 +1,146 @@
+require 'spec_helper'
+
+describe Casino::Collection do
+  describe "making a Casino collection" do
+    it { Collection.must_respond_to :dimension }
+    it { Collection.must_respond_to :focus }
+    it { Collection.must_respond_to :question }
+    it { Collection.must_respond_to :lobby }
+    it { Collection.must_respond_to :register }
+    it { Collection.new.must_respond_to :query }
+    it { Collection.new.must_respond_to :intersection }
+    it { Collection.new.must_respond_to :answer }
+    it { Collection.new.must_respond_to :projection }
+  end
+
+  describe '.dimension' do
+    let(:field) { :created_at }
+    let(:queries) { [] }
+    let(:approach) { { operator: :and } }
+    subject { Collection.dimension(field, queries, approach) }
+    it { subject.must_be_instance_of Casino::Dimension }
+    it "registers the dimension with the Lobby" do
+      dimension = Collection.dimension(field, queries, approach)
+      Collection.lobby.registry[:dimension].must_include dimension
+    end
+  end
+
+  describe '.focus' do
+    let(:model) { Model }
+    let(:focus) { Collection.focus(model) }
+    subject { focus }
+    it { subject.must_be_instance_of Casino::Focus }
+    it "registers the focus with the Lobby" do
+      focus = Collection.focus(Model)
+      Collection.lobby.registry[:focus].first.must_equal focus
+    end
+  end
+
+  describe '.question' do
+    let(:name) { :emails }
+    let(:answer) { -> { distinct(:email) } }
+    subject { Collection.question(name, answer) }
+    it { subject.must_be_instance_of Casino::Question }
+    it "registers the question with the Lobby" do
+      question = Collection.question(name, answer)
+      Collection.lobby.registry[:question].must_include question
+    end
+  end
+
+  describe 'instance methods' do
+
+    let(:emails_by_day) { EmailsByDay.new }
+
+    describe 'registry accessors' do
+
+      let(:registry) { emails_by_day.class.lobby.registry }
+      let(:dimensions) { registry[:dimension] }
+      let(:questions) { registry[:question] }
+      let(:focus) { registry[:focus] }
+
+      subject { emails_by_day }
+
+      it { subject.dimensions.must_equal dimensions }
+      it { subject.focus.must_equal focus }
+      it { subject.questions.must_equal questions }
+
+    end
+
+    describe '#query' do
+      subject { Collection.new.query('', '', '') }
+      it { subject.must_be_instance_of Casino::Query }
+    end
+
+    describe '#store' do
+      subject { emails_by_day.store }
+      it { subject.must_be_instance_of Casino::Store }
+    end
+
+    describe '#results' do
+      subject { emails_by_day.results }
+      it { subject.must_be_instance_of Mongoid::Criteria }
+    end
+
+    describe '#update' do
+      subject { emails_by_day.update }
+      it { subject.must_be_instance_of Mongoid::Criteria }
+    end
+
+    describe '#insert' do
+      subject { emails_by_day.insert(Model.new) }
+      it "returns a `Mongoid::Criteria`" do
+        subject.must_be_instance_of Mongoid::Criteria
+      end
+    end
+
+    describe '#projection' do
+
+      let(:selector) { Model.where(created_at: Time.now).selector }
+      let(:mock) { OpenStruct.new(selector: selector) }
+
+      subject { emails_by_day.projection }
+
+      it { subject.must_be_instance_of Casino::Projection }
+
+      it "is preloaded with the current criteria intersection" do
+        emails_by_day.stub(:intersection, mock) do
+          subject.pipeline.first['$match'].must_equal selector
+        end
+      end
+
+    end
+
+    describe '#intersection' do
+      subject { emails_by_day.intersection }
+      it { subject.must_be_instance_of Mongoid::Criteria }
+      it "defaults to the base model criteria" do
+        subject.must_equal Model.scoped
+      end
+    end
+
+    describe '#answer' do
+      subject { emails_by_day.answer(:count_emails) }
+      it "calls the target method" do
+        emails_by_day.stub(:count_emails, true) do
+          subject.must_equal true
+        end
+      end
+    end
+
+    describe '#key' do
+
+      let(:string) do
+        "emails_by_day_asks_model_about_unique_emails" +
+          "_by_created_at_and_source"
+      end
+
+      let(:key) { Digest::SHA1.hexdigest(string) }
+
+      subject { emails_by_day.key }
+      it { subject.must_equal key }
+
+    end
+
+  end
+
+end

data/spec/lib/casino/dimension_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Casino::Dimension do
+
+  let(:label) { "Date" }
+  let(:field) { :created_at }
+  let(:queries) { :method_name }
+  let(:and_approach) { { operator: :and } }
+  let(:where_approach) { { operator: :where } }
+
+  let(:dimension) do
+    Casino::Dimension.new(label, field, queries, and_approach)
+  end
+
+  subject { dimension }
+
+  it { subject.label.must_equal label }
+  it { subject.queries.must_equal queries }
+  it { subject.approach.must_equal and_approach }
+  it { subject.field.must_equal field }
+
+  it 'defaults #approach to operator: :where' do
+    dimension = Casino::Dimension.new(label, field, queries)
+    dimension.approach.must_equal where_approach
+  end
+
+end

data/spec/lib/casino/focus_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe Casino::Focus do
+
+  let(:model) { Model }
+  let(:focus) { Casino::Focus.new(model) }
+
+  subject { focus }
+
+  it { subject.model.must_equal model }
+
+  describe '#eql?' do
+
+    let(:match) { Casino::Focus.new(model) }
+    let(:no_match) { Casino::Focus.new(Class.new) }
+
+    it "is true when compared to another focus of the same model" do
+      subject.eql?(match).must_equal true
+    end
+
+    it "is false when compared to a different model focus" do
+      subject.eql?(no_match).must_equal false
+    end
+  end
+
+  describe '#hash' do
+    it "delegates to the model hash" do
+      subject.hash.must_equal model.hash
+    end
+  end
+
+  describe '#build_criteria' do
+
+    let(:conditions) do
+      [ [:where, { created_at: Time.now }],
+        [:and, { source: "Facebook" }] ]
+    end
+
+    let(:query) do
+      Casino::Query.new(:label, conditions)
+    end
+
+    subject { focus.build_criteria(query) }
+
+    it "produces a Mongoid::Criteria with the correct fields" do
+      [ "created_at", "$and" ].each do |field|
+        subject.selector.keys.must_include field
+      end
+    end
+
+  end
+
+end

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

@@ -0,0 +1,24 @@
+describe Casino::Intersection::Match::All do
+
+  let(:system) { Casino::Intersection::Match::All }
+
+  describe '#eligible?' do
+    let(:matcher) { system.new('$and', '', '', '') }
+    subject { matcher.eligible? }
+    it { subject.must_equal true }
+  end
+
+  describe '#evaluate' do
+
+    let(:matcher) { system.new('$and', '', '', [{}]) }
+    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/match/base_spec.rb

@@ -0,0 +1,159 @@
+# If it's a regular expression, match with =~
+# If it's a hash, recurse over the hash with the document
+# If it is in the following directives, do the directive operation:
+#   * $gt evaluates with >
+#   * $gte evaluates with >=
+#   * $lt evalutes with <
+#   * $lte evaluates with <=
+#   * $in evaluates with Array#include?
+#   * $and evalutes as a list with each element of the list
+#     representing a new level of Match::Base with its own
+#     key
+# If it's a string/integer, match with ==
+
+describe Casino::Intersection::Match::Base do
+
+  let(:base_class) { Casino::Intersection::Match::Base }
+  let(:document) { Model.new(created_at: 3.days.ago) }
+  let(:key) { 'created_at' }
+  let(:criteria) { Model.gt(created_at: 4.days.ago) }
+  let(:selector) { criteria.selector }
+  let(:value) { document.created_at }
+  let(:base) { base_class.new(document, key, selector, value) }
+  let(:source) { "Facebook" }
+  let(:label) { [source] }
+  let(:intersection) { Casino::Intersection.new(label, criteria) }
+
+  describe 'when the document has an equivalent value' do
+    let(:model) { Model.new(source: source) }
+    let(:criteria) { Model.where(source: source) }
+    subject { intersection.match?(model) }
+    it { subject.must_equal true }
+  end
+
+  describe 'when the document has a regular expression' do
+    let(:model) { Model.new(source: source) }
+    let(:criteria) { Model.where(source: /Face/i) }
+    subject { intersection.match?(model) }
+    it { subject.must_equal true }
+  end
+
+  describe 'directives' do
+
+    describe '$and' do
+      let(:model) { Model.new(source: "Facebook", created_at: 3.days.ago) }
+
+      let(:criteria) do
+        Model.and(:created_at.gt => 4.days.ago).
+          and(source: "Facebook")
+      end
+
+      subject { intersection.match?(model) }
+      it { subject.must_equal true }
+    end
+
+    describe '$in' do
+      let(:model) { Model.new(source: "Facebook") }
+      let(:criteria) { Model.in(source: "Facebook") }
+      subject { intersection.match?(model) }
+      it { subject.must_equal true }
+    end
+
+    describe '$gt' do
+      let(:model) { Model.new(created_at: 3.days.ago) }
+      let(:criteria) { Model.gt(created_at: 4.days.ago) }
+      subject { intersection.match?(model) }
+      it { subject.must_equal true }
+    end
+
+    describe '$lt' do
+      let(:model) { Model.new(created_at: 4.days.ago) }
+      let(:criteria) { Model.lt(created_at: 3.days.ago) }
+      subject { intersection.match?(model) }
+      it { subject.must_equal true }
+    end
+
+    describe '$gte' do
+      let(:model) { Model.new(created_at: 3.days.ago) }
+      let(:criteria) { Model.gte(created_at: 3.days.ago) }
+      subject { intersection.match?(model) }
+      it { subject.must_equal true }
+    end
+
+    describe '$lte' do
+      let(:three_days_ago) { 3.days.ago }
+      let(:model) { Model.new(created_at: three_days_ago) }
+      let(:criteria) { Model.lte(created_at: three_days_ago) }
+      subject { intersection.match?(model) }
+      it { subject.must_equal true }
+    end
+
+  end
+
+  describe 'creating a new matcher base' do
+
+    describe '#document' do
+      subject { base.document }
+      it { subject.must_equal document }
+    end
+
+    describe '#key' do
+      subject { base.key }
+      it { subject.must_equal key }
+    end
+
+    describe '#selector' do
+      subject { base.selector }
+      it { subject.must_equal selector }
+    end
+
+    describe '#field' do
+      subject { base.field }
+      it { subject.must_equal selector[key] }
+    end
+
+    describe '#value' do
+      subject { base.value }
+      it { subject.must_equal document.send(key) }
+    end
+
+  end
+
+  describe '#evaluate' do
+    it 'calls #evaluate on the given #matcher' do
+      matcher = MiniTest::Mock.new
+      matcher.expect :evaluate, nil
+      base.stub(:matcher, matcher) do
+        base.evaluate
+      end
+      matcher.verify
+    end
+  end
+
+  describe 'interfaces to matcher classes' do
+
+    describe '#matcher_for' do
+      it "creates a matcher for the given class name" do
+        matcher = base.matcher_for(:equivalence)
+        matcher.must_be_instance_of Casino::Intersection::Match::Equivalence
+      end
+    end
+
+    describe '#match_arguments' do
+      let(:arguments) { [base.key, base.value, base.document, base.field] }
+      subject { base.match_arguments }
+      it { subject.must_equal arguments }
+    end
+
+    describe '#matcher' do
+      it "finds the first eligible matcher" do
+        eligible_matcher = OpenStruct.new(eligible?: true)
+        base.stub(:matchers, [eligible_matcher]) do
+          base.matcher.must_equal eligible_matcher
+        end
+      end
+    end
+
+  end
+
+end