praxis-mapper 3.1.1

data/spec/praxis-mapper/query/base_spec.rb

@@ -0,0 +1,317 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Praxis::Mapper::Query::Base do
+  let(:scope) { {} }
+  let(:unloaded_ids) { [1, 2, 3] }
+  let(:connection) { double("connection") }
+  let(:identity_map) { double("identity_map", :scope => scope, :get_unloaded => unloaded_ids) }
+
+  let(:model) { SimpleModel }
+
+  let(:expected_ids_condition) { "id IN (#{unloaded_ids.join(", ")})" }
+
+  let(:query) { Praxis::Mapper::Query::Base.new(identity_map, model) }
+  subject { query }
+
+  let(:rows) { [
+                 {:id => 1, :name => "george jr", :parent_id => 1, :description => "one"},
+                 {:id => 2, :name => "george iii", :parent_id => 2, :description => "two"},
+                 {:id => 3, :name => "george xvi", :parent_id => 2, :description => "three"}
+  ] }
+  let(:ids) { rows.collect { |r| r[:id] } }
+
+
+  context "retrieving records" do
+
+    # TODO: refactor with shared_examples
+    context "#multi_get" do
+
+      it 'delegates to the subclass' do
+        query.should_receive(:_multi_get).and_return(rows)
+        response = query.multi_get(:id, ids)
+
+        response.should have(3).items
+
+        response.should eq(rows)
+        #record = response.first
+        #record.should be_kind_of(model)
+
+        #rows.first.each do |attribute, value|
+        #  record.send(attribute).should == value
+        #end
+
+      end
+
+      it 'raises if run on a frozen query' do
+        query.freeze
+        expect { query.multi_get(:id, ids) }.to raise_error(TypeError)
+      end
+
+      context 'for very large lists of values' do
+        let(:batch_size) { Praxis::Mapper::Query::Base::MULTI_GET_BATCH_SIZE }
+
+
+        let(:result_size) { (batch_size * 2.5).to_i }
+
+        let(:values) { (0..result_size).to_a }
+        let(:rows) { values.collect { |v| {:id => v} } }
+
+        before do
+          stub_const("Praxis::Mapper::Query::Base::MULTI_GET_BATCH_SIZE", 4)
+
+          rows.each_slice(batch_size) do |batch_rows|
+            ids = batch_rows.collect { |v| v.values }.flatten
+            query.should_receive(:_multi_get).with(:id, ids).and_return(batch_rows)
+          end
+        end
+
+        it 'batches queries and aggregates their results' do # FIXME: totally lame name for this
+          query.multi_get(:id, values).should =~ rows
+        end
+      end
+    end
+
+    context "#execute" do
+      it 'delegates to the subclass and wraps the response in model instances' do
+        query.should_receive(:_execute).and_return(rows)
+        response = query.execute
+
+        response.should have(3).items
+
+        item = response.first
+        item.should be_kind_of(model)
+
+        rows.first.each do |attribute, value|
+          item.send(attribute).should == value
+        end
+
+      end
+
+      it 'raises if run on a frozen query' do
+        query.freeze
+        expect { query.execute }.to raise_error(TypeError)
+      end
+
+    end
+
+    it 'raises for subclass methods' do
+      expect { subject._multi_get(nil, nil) }.to raise_error "subclass responsibility"
+      expect { subject._execute }.to raise_error "subclass responsibility"
+    end
+  end
+
+
+  context "the specification DSL" do
+
+    context "#select" do
+      it "accepts an array of symbols" do
+        subject.select :id, :name
+        subject.select.should include(:id => nil, :name => nil)
+      end
+
+      it "accepts an array of strings" do
+        subject.select "id", "name"
+        subject.select.should include("id" => nil, "name" => nil)
+      end
+
+      it "raises for unknown field types" do
+        expect { subject.select Object.new }.to raise_error
+      end
+
+      context "accepts an array of hashes" do
+        context "with strings for the field definitions" do
+          it "and symbols to specify the field aliases" do
+            definition = {:id => "IFNULL(foo,bar)", :name => "CONCAT(foo,bar)"}
+            subject.select definition
+            subject.select.should include(definition)
+          end
+          it "and strings to specify the field aliases" do
+            definition = {"id" => "IFNULL(foo,bar)", "name" => "CONCAT(foo,bar)"}
+            subject.select definition
+            subject.select.should include(definition)
+          end
+        end
+
+        context "with symbols for the field definitions" do
+          it "and symbols to specify the field aliases" do
+            definition = {:my_id => :id, :name => :name}
+            subject.select :my_id => :id, :name => :name
+            subject.select.should include :my_id => :id, :name => :name
+          end
+          it "and strings to specify the field aliases" do
+            definition = {"id" => "IFNULL(foo,bar)", "name" => "CONCAT(foo,bar)"}
+            subject.select definition
+            subject.select.should include(definition)
+          end
+        end
+
+      end
+      it "accepts an array of mixed hashes and symbols and strings" do
+        subject.select :id, "description", :name => "CONCAT(foo,bar)"
+        subject.select.should include(:id => nil, "description" => nil, :name => "CONCAT(foo,bar)")
+      end
+
+      it "also accepts a single symbol" do
+        subject.select :id
+        subject.select.should include(:id => nil)
+      end
+
+      it "also accepts a single hash" do
+        definition = {:id => "IFNULL(foo,bar)"}
+        subject.select definition
+        subject.select.should include(definition)
+      end
+
+    end
+
+    context "with no query body" do
+      subject { Praxis::Mapper::Query::Base.new(identity_map, model) }
+
+      it "should be an empty nil" do
+        subject.select.should be_nil
+      end
+
+      its(:where) { should be_nil }
+      its(:track) { should eq(Set[]) }
+
+      context "with all the fixings" do
+        subject do
+          Praxis::Mapper::Query::Base.new(identity_map, model) do
+            select :id, :name
+            where "deployment_id=2"
+            track :parent
+          end
+        end
+
+
+        its(:select) { should == {:id => nil, :name => nil} }
+        its(:where) { should eq("deployment_id=2") }
+        its(:track) { should eq(Set[:parent]) }
+
+        its(:tracked_associations) { should =~ [model.associations[:parent]] }
+
+      end
+
+    end
+
+    context '#track' do
+      context 'with nested track something or another' do
+        subject :query do
+          Praxis::Mapper::Query::Base.new(identity_map, PersonModel) do
+            track :address do
+              select :id, :name
+              track :residents
+            end
+          end
+        end
+
+        it 'saves the subcontext block' do
+          query.track.should have(1).item
+
+          name, tracked_address = query.track.first
+          name.should be(:address)
+          tracked_address.should be_kind_of(Proc)
+        end
+
+        its(:tracked_associations) { should =~ [PersonModel.associations[:address]] }
+
+      end
+
+      context 'tracking an association tracked by a context' do
+        subject :query do
+          Praxis::Mapper::Query::Base.new(identity_map, PersonModel) do
+            context :default
+            track :address do
+              select :id, :name
+              track :residents
+            end
+          end
+        end
+
+        it 'retains both values' do
+          query.track.should have(2).item
+
+          query.track.should include(:address)
+
+          # TODO: find a better way to do this match
+          name, tracked_address = query.track.to_a[1]
+          name.should be(:address)
+          tracked_address.should be_kind_of(Proc)
+        end
+
+        its(:tracked_associations) { should =~ [PersonModel.associations[:address]] }
+
+      end
+    end
+
+    context '#context' do
+      let(:model) { PersonModel }
+
+      subject do
+        Praxis::Mapper::Query::Base.new(identity_map, model) do
+          context :default
+          context :tiny
+          track :properties
+        end
+      end
+
+      its(:select) { should eq({id: nil, email: nil}) }
+      its(:track) { should eq(Set[:address, :properties]) }
+
+    end
+
+    context '#load' do
+      subject do
+        Praxis::Mapper::Query::Base.new(identity_map, model) do
+          load :address
+        end
+      end
+
+      its(:load) { should eq(Set[:address])}
+    end
+  end
+
+  context 'statistics' do
+    its(:statistics) { should == Hash.new }
+
+    it 'initialize new values with zero' do
+      subject.statistics[:execute].should == 0
+    end
+
+    context "#execute" do
+      before do
+        query.should_receive(:_execute).and_return(rows)
+        query.execute
+      end
+
+      it 'tracks the number of calls' do
+        query.statistics[:execute].should == 1
+      end
+      it 'tracks records loaded' do
+        query.statistics[:records_loaded].should == rows.size
+      end
+
+    end
+
+    context "#multi_get" do
+      before do
+        query.should_receive(:_multi_get).with(:id, ids).and_return(rows)
+        query.multi_get(:id, ids)
+      end
+
+      it 'tracks the number of calls' do
+        query.statistics[:multi_get].should == 1
+      end
+      it 'tracks records loaded' do
+        query.statistics[:records_loaded].should == rows.size
+      end
+
+    end
+  end
+
+  context "#raw" do
+    let(:model) { PersonModel }
+
+  end
+
+end

data/spec/praxis-mapper/query/sql_spec.rb

@@ -0,0 +1,184 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+# FIXME: figure out rspec's "should behave like" or whatever
+
+describe Praxis::Mapper::Query::Sql do
+  let(:scope) { {} }
+  let(:unloaded_ids) { [1, 2, 3] }
+  let(:identity_map) { Praxis::Mapper::IdentityMap.setup!(scope) }
+  let(:connection) { identity_map.connection(:default) }
+
+
+  let(:expected_ids_condition) { "id IN (#{unloaded_ids.join(", ")})" }
+
+  context "without a query body" do
+    subject { Praxis::Mapper::Query::Sql.new(identity_map, SimpleModel) }
+
+    its(:select_clause) { should eq("SELECT *") }
+    its(:from_clause) { should eq("FROM `simple_model`") }
+    its(:where_clause) { should be_nil }
+    its(:limit_clause) { should be_nil }
+
+    its(:sql) { should eq("SELECT *\nFROM `simple_model`") }
+
+    context 'with an integer value in the identity map' do
+      let(:scope) { {:tenant => [:account_id, 71]} }
+      its(:where_clause) { should eq("WHERE `account_id`=71") }
+    end
+
+    context 'with a string value in the identity map' do
+      let(:scope) { {:tenant => [:account_id, '71']} }
+      its(:where_clause) { should eq("WHERE `account_id`='71'") }
+    end
+
+    context 'with a nil value in the identity map' do
+      let(:scope) { {:tenant => [:account_id, nil]} }
+      its(:where_clause) { should eq("WHERE `account_id` IS NULL") }
+    end
+
+  end
+
+  context "#raw" do
+    subject do
+      Praxis::Mapper::Query::Sql.new(identity_map, SimpleModel) do
+        raw "SELECT id, parent_id\nFROM table\nWHERE id=123\nGROUP BY id"
+      end
+    end
+
+    it 'uses the exact raw query for the final SQL statement' do
+      subject.sql.should eq("SELECT id, parent_id\nFROM table\nWHERE id=123\nGROUP BY id")
+    end
+  end
+
+
+  context "with all the fixings" do
+    subject do
+      Praxis::Mapper::Query::Sql.new(identity_map, SimpleModel) do
+        select :id, :name
+        where "deployment_id=2"
+        track :parent
+      end
+    end
+
+    it "generates the correct select statement" do
+      str = subject.select_clause
+      str.should =~ /^\s*SELECT/
+      fields = str.gsub(/^\s*SELECT\s*/, "").split(',').map { |field| field.strip }
+      fields.should =~ ["id", "name"]
+    end
+
+    its(:where_clause) { should eq("WHERE deployment_id=2") }
+
+    it "should generate SQL by joining the select, from and where clauses with newlines" do
+      subject.sql.should == [subject.select_clause, subject.from_clause, subject.where_clause].compact.join("\n")
+    end
+
+    context 'a scope in the identity map' do
+      let(:scope) { {:tenant => [:account_id, 71]} }
+      its(:where_clause) { should eq("WHERE `account_id`=71 AND deployment_id=2") }
+
+      context 'with a nil value' do
+        let(:scope) { {:deleted => [:deleted_at, nil]} }
+        its(:where_clause) { should eq("WHERE `deleted_at` IS NULL AND deployment_id=2") }
+      end
+    end
+
+    context 'an ignored scope in the identity map' do
+      let(:scope) { {:account => [:account_id, 71]} }
+      its(:where_clause) { should eq("WHERE deployment_id=2") }
+    end
+
+  end
+
+  context '#_multi_get' do
+
+    let(:ids) { [1, 2, 3] }
+    let(:names) { ["george xvi"] }
+    let(:expected_id_condition) { "(id IN (#{ids.join(", ")}))" }
+    let(:expected_name_condition) { "(name IN ('george xvi'))" }
+
+    let(:query) { Praxis::Mapper::Query::Sql.new(identity_map, ItemModel) }
+
+    it "constructs a where clause for Integer keys" do
+      query.should_receive(:where).with(expected_id_condition)
+      query.should_receive(:_execute)
+
+      query._multi_get :id, ids
+    end
+
+    it "constructs a where clause for String keys" do
+      query.should_receive(:where).with(expected_name_condition)
+      query.should_receive(:_execute)
+
+      query._multi_get :name, names
+    end
+
+    context "with composite identities" do
+
+      context "where each sub-key is an Integer" do
+        let(:ids) { [[1, 1], [2, 2], [3, 2]] }
+        let(:expected_composite_condition) { "(((id, parent_id) IN ((1, 1), (2, 2), (3, 2))) AND (id IN (1, 2, 3)))" }
+        it 'constructs a query using SQL composite constructs (parenthesis syntax)' do
+          query.should_receive(:where).with(expected_composite_condition)
+          query.should_receive(:_execute)
+
+          query._multi_get [:id, :parent_id], ids
+        end
+      end
+
+      context "where sub-keys are strings" do
+        let(:ids) { [[1, "george jr"], [2, "george iii"], [3, "george xvi"]] }
+        let(:expected_composite_condition) { "(((id, name) IN ((1, 'george jr'), (2, 'george iii'), (3, 'george xvi'))) AND (id IN (1, 2, 3)))" }
+        it 'quotes only the string subkeys in the constructed composite query syntax' do
+          query.should_receive(:where).with(expected_composite_condition)
+          query.should_receive(:_execute)
+
+          query._multi_get [:id, :name], ids
+        end
+      end
+    end
+
+    it "tracks datastore interactions" do
+      query._multi_get :ids, [1,2,3]
+
+      query.statistics[:datastore_interactions].should == 1
+    end
+
+  end
+
+
+
+
+  context '#_execute' do
+    let(:rows) { [
+                   {:id => 1, :name => "foo", :parent_id => 1},
+                   {:id => 2, :name => "bar", :parent_id => 2},
+                   {:id => 3, :name => "snafu", :parent_id => 3}
+    ] }
+
+    subject { Praxis::Mapper::Query::Sql.new(identity_map, SimpleModel) }
+    before do
+      connection.should_receive(:fetch).and_return(rows)
+      identity_map.should_receive(:connection).with(:default).and_return(connection)
+
+      Time.should_receive(:now).and_return(Time.at(0), Time.at(10))
+
+    end
+
+    it 'wraps database results in SimpleModel instances' do
+      records = subject.execute
+      records.each { |record| record.should be_kind_of(SimpleModel) }
+    end
+
+    it "tracks datastore interactions" do
+      subject.execute
+      subject.statistics[:datastore_interactions].should == 1
+    end
+
+    it 'times datastore interactions' do
+      subject.execute
+      subject.statistics[:datastore_interaction_time].should == 10
+    end
+
+  end
+end

data/spec/praxis-mapper/resource_spec.rb

@@ -0,0 +1,154 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Praxis::Mapper::Resource do
+
+  let(:parent_record) { ParentModel.new(id: 100, name: 'george sr') }
+  let(:parent_records) { [ParentModel.new(id: 101, name: "georgia"),ParentModel.new(id: 102, name: 'georgina')] }
+  let(:record) { SimpleModel.new(id: 103, name: 'george xvi') }
+  let(:model) { SimpleModel}
+
+  let(:identity_map) { Praxis::Mapper::IdentityMap.current }
+
+  before do
+    identity_map.add_records([parent_record]| parent_records)
+    identity_map.add_records([record])
+  end
+
+  context 'configuration' do
+    subject { SimpleResource }
+    its(:model) { should == model }
+    its(:member_name) { should == 'simple_resource' }
+    its(:collection_name) { should == 'simple_resources' }
+  end
+
+
+  context 'retrieving resources' do
+
+    context 'getting a single resource' do
+      subject(:resource)  { SimpleResource.get(:name => 'george xvi') }
+
+      it { should be_kind_of(SimpleResource) }
+
+      its(:record) { should be record }
+    end
+
+    context 'getting multiple resources' do
+      subject(:resource_collection) { SimpleResource.all(:name => ["george xvi"]) }
+
+      it { should be_kind_of(Array) }
+
+      it 'fetches the models and wraps them' do
+        resource = resource_collection.first
+        resource.should be_kind_of(SimpleResource)
+        resource.record.should == record
+
+      end
+    end
+  end
+
+  context 'delegating to the underlying model' do
+
+    subject { SimpleResource.new(record) }
+
+    it 'does respond_to attributes in the model' do
+      subject.should respond_to(:name)
+    end
+
+    it 'does not respond_to :id if the model does not have it' do
+      resource = OtherResource.new(OtherModel.new(:name => "foo"))
+
+      resource.should_not respond_to(:id)
+    end
+
+
+    it 'returns raw results for simple attributes' do
+      record.should_receive(:name).and_call_original
+      subject.name.should == "george xvi"
+    end
+
+    it 'wraps model objects in Resource instances' do
+      record.should_receive(:parent).and_return(parent_record)
+
+      parent = subject.parent
+
+      parent.should be_kind_of(ParentResource)
+      parent.name.should == "george sr"
+      parent.record.should == parent_record
+    end
+
+    context "for serialized array associations" do
+      let(:record) { YamlArrayModel.new(:id => 1)}
+
+      subject { YamlArrayResource.new(record)}
+
+      it 'wraps arrays of model objects in an array of resource instances' do
+        record.should_receive(:parents).and_return(parent_records)
+
+        parents = subject.parents
+        parents.should have(parent_records.size).items
+        parents.should be_kind_of(Array)
+
+        parents.each { |parent| parent.should be_kind_of(ParentResource) }
+        parents.collect { |parent| parent.record }.should =~ parent_records
+      end
+    end
+  end
+
+  context 'resource_delegate' do
+    let(:other_name) { "foo" }
+    let(:other_attribute) { "other value" }
+    let(:other_record) { OtherModel.new(:name => other_name, :other_attribute => other_attribute)}
+    let(:other_resource) { OtherResource.new(other_record) }
+
+    let(:record) { SimpleModel.new(id: 105, name: "george xvi", other_name: other_name) }
+
+    subject(:resource) { SimpleResource.new(record) }
+
+    before do
+      identity_map.add_records([other_record])
+    end
+
+    it 'delegates to the target' do
+      resource.other_attribute.should == other_attribute
+    end
+  end
+
+
+  context "memoized resource creation" do
+    let(:other_name) { "foo" }
+    let(:other_attribute) { "other value" }
+    let(:other_record) { OtherModel.new(:name => other_name, :other_attribute => other_attribute)}
+    let(:other_resource) { OtherResource.new(other_record) }
+    let(:record) { SimpleModel.new(id: 105, name: "george xvi", other_name: other_name) }
+
+    before do
+      identity_map.add_records([other_record])
+      identity_map.add_records([record])
+    end
+
+    subject(:resource) { SimpleResource.new(record) }
+
+    it 'memoizes related resource creation' do
+      resource.other_resource.should be(SimpleResource.new(record).other_resource)
+    end
+
+  end
+
+
+  context ".wrap" do
+    it 'memoizes resource creation' do
+      SimpleResource.wrap(record).should be(SimpleResource.wrap(record))
+    end
+
+    it 'works with nil resources, returning an empty set' do
+      wrapped_obj = SimpleResource.wrap(nil)
+      wrapped_obj.should be_kind_of(Array)
+      wrapped_obj.length.should be(0)
+    end
+
+    it 'works regardless of the resource class used' do
+      SimpleResource.wrap(record).should be(OtherResource.wrap(record))
+    end
+  end
+
+end

data/spec/praxis_mapper_spec.rb

@@ -0,0 +1,21 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Praxis::Mapper do
+
+  context '.logger' do
+    it 'returns a default logger' do
+      Praxis::Mapper.logger
+    end
+
+    it 'allows assignment of Praxis::Mapper logger' do
+      Praxis::Mapper.logger = Logger.new(STDOUT)
+    end
+
+    it 'returns the assigned logger' do
+      logger = Logger.new(STDOUT)
+      Praxis::Mapper.logger = logger
+      Praxis::Mapper.logger.should === logger
+    end
+  end
+
+end

data/spec/spec_fixtures.rb

@@ -0,0 +1,12 @@
+# A test model with an example generator
+class SimpleModel < Praxis::Mapper::Model
+  def self.generate
+    data = {
+      :id => /\d{10}/.gen.to_i, 
+      :name => /\w+/.gen, 
+      :parent_id  => /\d{10}/.gen.to_i
+    }
+
+    self.new(data)
+  end
+end