daodalus 0.1.1

data/spec/lib/daodalus/dao_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+module Daodalus
+  describe DAO do
+
+    it 'takes a collection and connection name' do
+      expect { DAO.new(:animalhouse, :cats, :animalhouse) }.to_not raise_error
+    end
+
+    it 'is not necessary to specify the connection name' do
+      expect { DAO.new(:animalhouse, :cats) }.to_not raise_error
+    end
+
+    let (:dao) { DAO.new(:animalhouse, :cats) }
+
+    it 'holds a connection to the mongo DB collection' do
+      dao.coll.should be_a Mongo::Collection
+    end
+
+    it 'delegates basic mongo methods to its coll' do
+      dao.coll.should_receive(:find)
+      dao.find
+    end
+
+    it 'returns an optional value for find_one' do
+      dao.find_one(name: 'felix').should be_none
+    end
+
+    it 'returns an optional value for find_and_modify' do
+      dao.find_and_modify(query: { name: 'felix'}, update: { '$set' => { name: 'cat' }}).should be_none
+    end
+
+  end
+end

data/spec/lib/daodalus/dsl/aggregation/group_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+module Daodalus
+  module DSL
+    module Aggregation
+      describe Group do
+
+        let (:dao) { DAO.new(:animalhouse, :cats) }
+
+        before do
+          dao.insert('name'  => 'Terry',
+                     'paws'  => 3,
+                     'likes' => ['tuna', 'catnip'],
+                     'foods' => [{'type' => 'dry', 'name' => 'go cat'},
+                                 {'type' => 'wet', 'name' => 'whiskas'}])
+
+          dao.insert('name'  => 'Jemima',
+                     'paws'  => 3,
+                     'likes' => ['tuna', 'ginger beer'],
+                     'foods' => [{'type' => 'cat', 'name' => 'go cat'},
+                                 {'type' => 'dog', 'name' => 'whiskas'}])
+        end
+
+        it 'can group on a single field' do
+          dao.group_by('$foods.type').aggregate.should eq [
+            {"_id"=>["cat", "dog"]},
+            {"_id"=>["dry", "wet"]}
+          ]
+        end
+
+        it 'can group by a hash of fields' do
+          dao.group_by(cat: '$name', brand: '$foods.name').aggregate.should eq [
+            {"_id"=>{"cat"=>"Jemima", "brand"=>["go cat", "whiskas"]}},
+            {"_id"=>{"cat"=>"Terry", "brand"=>["go cat", "whiskas"]}}
+          ]
+        end
+
+        it 'can sum a set of fields' do
+          dao.group_by(1).sum("$paws").as(:paws).aggregate.should eq [{"_id"=>1, "paws"=>6}]
+        end
+
+        it 'can build up a unique set of aggregate values' do
+          dao.insert('name'  => 'Terry', 'paws' => 3)
+          dao.group_by("$paws").distinct("$name").as(:cats).aggregate.should eq [
+            {"_id"=>3, "cats"=>["Jemima", "Terry"]}
+          ]
+        end
+
+        it 'can build up a non-unique set of aggregate values' do
+          dao.insert('name'  => 'Terry', 'paws' => 3)
+          dao.group_by(:"$paws").collect("$name").as(:cats).aggregate.should eq [
+            {"_id"=>3, "cats"=>["Terry", "Jemima", "Terry"]}
+          ]
+        end
+
+        it 'can get the first value for an aggregate field' do
+          dao.group_by(1).first('$name').as(:name).aggregate.should eq [
+            {"_id"=>1, "name"=>"Terry"}
+          ]
+        end
+
+        it 'can get the last value for an aggregate field' do
+          dao.group_by(1).last('$name').as(:name).aggregate.should eq [
+            {"_id"=>1, "name"=>"Jemima"}
+          ]
+        end
+
+        it 'can get the min value for an aggregate field' do
+          dao.insert('name'  => 'Terry', 'paws' => 7)
+          dao.group_by(1).min('$paws').as(:paws).aggregate.should eq [
+            {"_id"=>1, "paws"=>3}
+          ]
+        end
+
+        it 'can get the max value for an aggregate field' do
+          dao.insert('name'  => 'Terry', 'paws' => 7)
+          dao.group_by(1).max('$paws').as(:paws).aggregate.should eq [
+            {"_id"=>1, "paws"=>7}
+          ]
+        end
+
+        it 'can get the average value for an aggregate field' do
+          dao.insert('name'  => 'Terry', 'paws' => 24)
+          dao.group_by(1).average('$paws').as(:paws).aggregate.should eq [
+            {"_id"=>1, "paws"=>10}
+          ]
+        end
+
+      end
+    end
+  end
+end

data/spec/lib/daodalus/dsl/aggregation/limit_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+module Daodalus
+  module DSL
+    module Aggregation
+      describe Limit do
+
+        let (:dao) { DAO.new(:animalhouse, :cats) }
+
+        before do
+          dao.insert('name'  => 'Terry')
+          dao.insert('name'  => 'Jemima')
+        end
+
+        it 'allows an aggregation query to be limited' do
+          dao.limit(1).project(:name).aggregate.should eq ['name' => 'Terry']
+        end
+
+      end
+    end
+  end
+end

data/spec/lib/daodalus/dsl/aggregation/match_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+module Daodalus
+  module DSL
+    module Aggregation
+      describe Match do
+
+        let (:dao) { DAO.new(:animalhouse, :cats) }
+
+        before do
+          dao.insert('name'  => 'Terry',
+                     'paws'  => 3,
+                     'likes' => ['tuna', 'catnip'],
+                     'foods' => [{'type' => 'dry', 'name' => 'go cat'},
+                                 {'type' => 'wet', 'name' => 'whiskas'}])
+        end
+
+        it 'allows queries to be made on the pipeline' do
+          dao.match(:name).eq('Terry').and(paws: 3).aggregate.should have(1).item
+          dao.match(:name).eq('Terry').aggregate.first.fetch('paws').should eq 3
+        end
+
+        it 'also works with the logical query operators' do
+          dao.match.any(
+            dao.where(:name).eq('Terrence'),
+            dao.where(:name).eq('Terry')
+          ).aggregate.should have(1).item
+        end
+      end
+    end
+  end
+end

data/spec/lib/daodalus/dsl/aggregation/project_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+module Daodalus
+  module DSL
+    module Aggregation
+      describe Project do
+
+        let (:dao) { DAO.new(:animalhouse, :cats) }
+
+        before do
+          dao.insert('name'  => 'Terry',
+                     'nickname' => 'Terry',
+                     'breed' => 'Tabby',
+                     'paws'  => 3,
+                     'likes' => ['tuna', 'catnip'],
+                     'foods' => [{'type' => 'dry', 'name' => 'go cat'},
+                                 {'type' => 'wet', 'name' => 'whiskas'}])
+
+        end
+
+        it 'can project a list of fields' do
+          dao.project(:name, :paws, 'foods.name').aggregate.should eq [
+            {'name' => 'Terry', 'paws' => 3, "foods"=>[{"name"=>"go cat"}, {"name"=>"whiskas"}] }
+          ]
+        end
+
+        it 'can rename fields' do
+          dao.project(feet: '$paws').aggregate.should eq ['feet' => 3]
+        end
+
+        it 'can be chained with other projects' do
+          dao.project(:paws).and(cat: '$name').aggregate.should eq ['paws' => 3, 'cat' => 'Terry']
+        end
+
+        it 'can alias fields using "as"' do
+          dao.project(:paws).and("$name").as(:cat).aggregate.should eq ['paws' => 3, 'cat' => 'Terry']
+        end
+
+        it 'implements the #eq function' do
+          dao.project("$name").eq("$nickname").as(:thingy).aggregate.should eq [ 'thingy' => true ]
+          dao.project("$name").eq("$breed").as(:thingy).aggregate.should eq [ 'thingy' => false ]
+          dao.project("$name").eq('Terry').as(:thingy).aggregate.should eq [ 'thingy' => true ]
+        end
+
+        it 'implements the #plus function' do
+          dao.project("$paws", 1).plus("$paws", 4).as(:thingy).aggregate.should eq [ 'thingy' => 11 ]
+        end
+
+        it 'implements the #divide function' do
+          dao.project("$paws").divided_by("$paws").as(:thingy).aggregate.should eq [ 'thingy' => 1 ]
+        end
+
+        it 'implements the #multiply function' do
+          dao.project("$paws").multiplied_by("$paws").as(:thingy).aggregate.should eq [ 'thingy' => 9 ]
+        end
+
+        it 'implements the #subtract function' do
+          dao.project("$paws").minus("$paws").as(:thingy).aggregate.should eq [ 'thingy' => 0 ]
+        end
+
+        it 'implements the #mod function' do
+          dao.project("$paws").mod(5).as(:thingy).aggregate.should eq [ 'thingy' => 3 ]
+        end
+
+        it 'can create nested documents' do
+          dao.project(
+            dao.project("$paws").as(:feet).and(name: "$name"),
+          ).as(:cat).aggregate.should eq [{"cat"=>{"feet"=>3, "name"=>"Terry"}}]
+        end
+
+      end
+    end
+  end
+end

data/spec/lib/daodalus/dsl/aggregation/skip_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+module Daodalus
+  module DSL
+    module Aggregation
+      describe Skip do
+
+        let (:dao) { DAO.new(:animalhouse, :cats) }
+
+        before do
+          dao.insert('name'  => 'Terry')
+          dao.insert('name'  => 'Jemima')
+        end
+
+        it 'allows an aggregation query to skip some records' do
+          dao.skip(1).project(:name).aggregate.should eq ['name' => 'Jemima']
+        end
+
+      end
+    end
+  end
+end

data/spec/lib/daodalus/dsl/aggregation/sort_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+module Daodalus
+  module DSL
+    module Aggregation
+      describe Sort do
+
+        let (:dao) { DAO.new(:animalhouse, :cats) }
+
+        before do
+          dao.insert('name'  => 'Terry', paws: 2)
+          dao.insert('name'  => 'Jemima', paws: 4)
+        end
+
+        it 'allows an aggregation query to be sorted' do
+          dao.sort(name: 1).project(:name).aggregate.should eq [
+            {"name"=>"Jemima"},
+            {"name"=>"Terry"}
+          ]
+          dao.sort(name: -1).project(:name).aggregate.should eq [
+            {"name"=>"Terry"},
+            {"name"=>"Jemima"}
+          ]
+        end
+
+        it 'accepts symbols for sort order' do
+          dao.sort(paws: :desc).project(:name).aggregate.should eq [
+            {"name"=>"Jemima"},
+            {"name"=>"Terry"}
+          ]
+        end
+
+      end
+    end
+  end
+end

data/spec/lib/daodalus/dsl/aggregation/unwind_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+module Daodalus
+  module DSL
+    module Aggregation
+      describe Unwind do
+
+        let (:dao) { DAO.new(:animalhouse, :cats) }
+
+        before do
+          dao.insert('name'  => 'Terry', 'likes' => ['tuna', 'cakes'])
+        end
+
+        it 'allows an aggregation query to be unwound' do
+          dao.unwind(:likes).project(:name, :likes).aggregate.should eq [
+            {"name"=>"Terry", "likes"=>"tuna"},
+            {"name"=>"Terry", "likes"=>"cakes"}
+          ]
+        end
+
+      end
+    end
+  end
+end

data/spec/lib/daodalus/dsl/clause_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+module Daodalus
+  module DSL
+    describe Clause do
+
+      let (:dao) { DAO.new(:animalhouse, :cats) }
+
+      it 'allows you to get the current query' do
+        dao.where(:name).eq('Trevor').to_query.should be_a Hash
+      end
+
+      it 'allows you to get the current projection' do
+        dao.where(:name).eq('Trevor').to_projection.should be_a Hash
+      end
+
+      it 'allows you to get the current update' do
+        dao.where(:name).eq('Trevor').to_update.should be_a Hash
+      end
+    end
+  end
+end

data/spec/lib/daodalus/dsl/query_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+module Daodalus
+  module DSL
+    describe Query do
+
+      let (:dao)   { DAO.new(:animalhouse, :cats) }
+      let (:query) { dao.query }
+
+      it 'can have a where clause added to it' do
+        query.where(paws: 3).wheres.should eq ({paws: 3})
+      end
+
+      it 'can have multiple where clauses added to it' do
+        q = query.where('paws' => 3).where('tail' => 'waggy')
+        q.wheres.should eq ({'paws' => 3, 'tail' => 'waggy'})
+      end
+
+      it 'merges clauses where possible' do
+        q = query.where('paws' => { '$gte' => 3}).where('paws' => {'$lte' => 6})
+        q.wheres.should eq ({'paws' => {'$gte'=>3, '$lte'=>6}})
+      end
+
+      it 'raises an error if two clauses cannot be merged' do
+        expect { query.where('paws' => 3).where('paws' => 4) }.to raise_error InvalidQueryError
+      end
+
+      it 'can have select clauses added to it' do
+        q = query.select('paws' => 1, 'tail' => 1)
+        q.selects.should eq ({'_id' => 0, 'paws' => 1, 'tail' => 1})
+      end
+
+    end
+  end
+end

data/spec/lib/daodalus/dsl/select_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+module Daodalus
+  module DSL
+    describe Select do
+
+      let (:dao) { DAO.new(:animalhouse, :cats) }
+
+      before do
+        dao.insert('name'  => 'Terry',
+                   'paws'  => 3,
+                   'likes' => ['tuna', 'catnip'],
+                   'lives' => [1,2,3,4,5,6,7,8,9],
+                   'foods' => [{'type' => 'dry', 'name' => 'go cat'},
+                               {'type' => 'wet', 'name' => 'whiskas'}])
+      end
+
+      it 'allows the selection of fields to be returned' do
+        dao.select(:name, :paws).find_one.value.keys.should eq ['name', 'paws']
+      end
+
+      it 'allows the chaining of selects' do
+        dao.select(:name).and(:paws).find_one.value.keys.should eq ['name', 'paws']
+      end
+
+      it 'allows use of the positional operator' do
+        query = dao.select(:foods).by_position.where(:'foods.type').eq('wet')
+        result = query.find_one.value
+        result.fetch('foods').should eq (['type' => 'wet', 'name' => 'whiskas'])
+      end
+
+      it 'implements #slice' do
+        dao.select(:lives).slice(-3).find_one.value.fetch('lives').should eq [7,8,9]
+        dao.select(:lives).slice(-3, 3).find_one.value.fetch('lives').should eq [7,8,9]
+        dao.select(:lives).slice(6, 5).find_one.value.fetch('lives').should eq [7,8,9]
+      end
+
+      it 'implements #elem_match' do
+        dao.select(:foods).elem_match(
+          dao.where(:type).eq(:wet)
+        ).find_one.value.fetch('foods').first.fetch('name').should eq 'whiskas'
+      end
+
+    end
+  end
+end