praxis 0.21 → 2.0.pre.3

data/spec/praxis/extensions/field_selection/support/spec_resources_active_model.rb

@@ -0,0 +1,130 @@
+require 'active_record'
+
+require 'praxis/mapper/active_model_compat'
+
+# Creates a new in-memory DB, and the necessary tables (and mini-seeds) for the  models in this file
+def create_tables
+
+  ActiveRecord::Base.establish_connection(
+      adapter:  'sqlite3',
+      dbfile:  ':memory:',
+      database: ':memory:'
+  )
+  
+  ActiveRecord::Schema.define do
+    ActiveRecord::Migration.suppress_messages do
+      create_table :active_books do |table|
+        table.column :simple_name, :string
+        table.column :added_column, :string
+        table.column :category_uuid, :string
+        table.column :author_id, :integer
+      end
+  
+      create_table :active_authors do |table|
+        table.column :name, :string
+      end
+  
+      create_table :active_categories do |table|
+        table.column :uuid, :string
+        table.column :name, :string
+      end
+  
+      create_table :active_tags do |table|
+        table.column :name, :string
+      end
+  
+      create_table :active_taggings do |table|
+        table.column :book_id, :integer
+        table.column :tag_id, :integer
+      end
+    end
+  end
+end
+
+create_tables
+
+class ActiveBook < ActiveRecord::Base
+  include Praxis::Mapper::ActiveModelCompat
+
+  belongs_to :category, class_name: 'ActiveCategory', foreign_key: :category_uuid, primary_key: :uuid
+  belongs_to :author, class_name: 'ActiveAuthor'
+  has_many :taggings, class_name: 'ActiveTagging', foreign_key: :book_id
+  has_many :tags, class_name: 'ActiveTag', through: :taggings
+end
+
+class ActiveAuthor < ActiveRecord::Base
+  include Praxis::Mapper::ActiveModelCompat
+  has_many :books, class_name: 'ActiveBook', foreign_key: :author_id
+end
+
+class ActiveCategory < ActiveRecord::Base
+  include Praxis::Mapper::ActiveModelCompat
+  has_many :books, class_name: 'ActiveBook', primary_key: :uuid, foreign_key: :category_uuid
+end
+
+class ActiveTag < ActiveRecord::Base
+  include Praxis::Mapper::ActiveModelCompat
+end
+
+class ActiveTagging < ActiveRecord::Base
+  include Praxis::Mapper::ActiveModelCompat
+  belongs_to :book, class_name: 'ActiveBook', foreign_key: :book_id
+  belongs_to :tag, class_name: 'ActiveTag', foreign_key: :tag_id
+end
+
+
+# A set of resource classes for use in specs
+class ActiveBaseResource < Praxis::Mapper::Resource
+end
+
+class ActiveAuthorResource < ActiveBaseResource
+  model ActiveAuthor
+
+  property :display_name, dependencies: [:name]
+end
+
+class ActiveCategoryResource < ActiveBaseResource
+  model ActiveCategory
+end
+
+class ActiveTagResource < ActiveBaseResource
+  model ActiveTag
+end
+
+class ActiveBookResource < ActiveBaseResource
+  model ActiveBook
+
+  # Forces to add an extra column (added_column)...and yet another (author_id) that will serve
+  # to check that if that's already automatically added due to an association, it won't interfere or duplicate
+  property :author, dependencies: [:author, :added_column, :author_id]
+
+  property :name, dependencies: [:simple_name]
+end
+
+
+def seed_data
+  cat1 = ActiveCategory.create( id: 1 , uuid: 'deadbeef1', name: 'cat1' )
+  cat2 = ActiveCategory.create( id: 2 , uuid: 'deadbeef2', name: 'cat2' )
+  
+  author1 = ActiveAuthor.create(  id: 11, name: 'author1' )
+  author2 = ActiveAuthor.create(  id: 22, name: 'author2' )
+  
+  tag_blue = ActiveTag.create(id: 1 , name: 'blue' )
+  tag_red = ActiveTag.create(id: 2 , name: 'red' )
+
+  book1 = ActiveBook.create( id: 1 , simple_name: 'Book1', category_uuid: 'deadbeef1')
+  book1.author = author1
+  book1.category = cat1
+  book1.save
+  ActiveTagging.create(book: book1, tag: tag_blue)
+  ActiveTagging.create(book: book1, tag: tag_red)
+  
+
+  book2 = ActiveBook.create( id: 2 , simple_name: 'Book2', category_uuid: 'deadbeef1')
+  book2.author = author2
+  book2.category = cat2
+  book2.save
+  ActiveTagging.create(book: book2, tag: tag_red)
+end
+
+seed_data

data/spec/praxis/extensions/field_selection/support/spec_resources_sequel.rb

@@ -0,0 +1,106 @@
+require 'sequel'
+
+require 'praxis/mapper/sequel_compat'
+
+
+# Creates a new in-memory DB, and the necessary tables (and mini-seeds) for the sequel models in this file
+def create_and_seed_tables
+    sequeldb = Sequel.sqlite 
+    # sequeldb.loggers = [Logger.new($stdout)] # Uncomment to see sequel logs
+
+    sequeldb.create_table! :sequel_simple_models do
+      primary_key :id
+      String :simple_name
+      Integer :parent_id
+      String :parent_uuid
+      Integer :other_model_id
+      String :added_column
+  end
+    sequeldb.create_table! :sequel_other_models do
+      primary_key :id
+    end
+    sequeldb.create_table! :sequel_parent_models do
+      primary_key :id
+      String :uuid
+    end
+    sequeldb.create_table! :sequel_tag_models do
+      primary_key :id
+      String :tag_name
+    end
+    sequeldb.create_table! :sequel_simple_models_sequel_tag_models do
+      Integer :sequel_simple_model_id
+      Integer :tag_id
+    end
+
+    sequeldb[:sequel_parent_models] << { id: 1 , uuid: 'deadbeef1'}
+    sequeldb[:sequel_parent_models] << { id: 2 , uuid: 'deadbeef2'}
+    
+    sequeldb[:sequel_other_models] << { id: 11 }
+    sequeldb[:sequel_other_models] << { id: 22 }
+
+    sequeldb[:sequel_tag_models] << { id: 1 , tag_name: 'blue' }
+    sequeldb[:sequel_tag_models] << { id: 2 , tag_name: 'red' }
+
+    # Simple model 1 is tagged as blue and red
+    sequeldb[:sequel_simple_models_sequel_tag_models] << { sequel_simple_model_id: 1, tag_id: 1 }
+    sequeldb[:sequel_simple_models_sequel_tag_models] << { sequel_simple_model_id: 1, tag_id: 2 }
+    # Simple model 2 is tagged as red
+    sequeldb[:sequel_simple_models_sequel_tag_models] << { sequel_simple_model_id: 2, tag_id: 2 }
+
+    # It's weird to have a parent id and parent uuid (which points to different actual parents)
+    # But it allows us to check pointing to both PKs and not PK columns
+    sequeldb[:sequel_simple_models] << { id: 1 , simple_name: 'Simple1', parent_id: 1, other_model_id: 11, parent_uuid: 'deadbeef1'}
+    sequeldb[:sequel_simple_models] << { id: 2 , simple_name: 'Simple2', parent_id: 2, other_model_id: 22, parent_uuid: 'deadbeef1'}
+end
+
+create_and_seed_tables
+
+class SequelSimpleModel < Sequel::Model
+  include Praxis::Mapper::SequelCompat
+
+  many_to_one :parent, class: 'SequelParentModel'
+  many_to_one :other_model, class: 'SequelOtherModel'
+  many_to_many :tags, class: 'SequelTagModel'
+end
+
+class SequelOtherModel < Sequel::Model
+  include Praxis::Mapper::SequelCompat
+end
+
+class SequelParentModel < Sequel::Model
+  include Praxis::Mapper::SequelCompat
+  one_to_many :children, class: 'SequelSimpleModel', primary_key: :uuid, key: :parent_uuid
+end
+
+class SequelTagModel < Sequel::Model
+  include Praxis::Mapper::SequelCompat
+end
+
+
+# A set of resource classes for use in specs
+class SequelBaseResource < Praxis::Mapper::Resource
+end
+
+class SequelOtherResource < SequelBaseResource
+  model SequelOtherModel
+
+  property :display_name, dependencies: [:name]
+end
+
+class SequelParentResource < SequelBaseResource
+  model SequelParentModel
+end
+
+class SequelTagResource < SequelBaseResource
+  model SequelTagModel
+end
+
+class SequelSimpleResource < SequelBaseResource
+  model SequelSimpleModel
+
+  # Forces to add an extra column (added_column)...and yet another (parent_id) that will serve
+  # to check that if that's already automatically added due to an association, it won't interfere or duplicate
+  property :parent, dependencies: [:parent, :added_column, :parent_id]
+
+  property :name, dependencies: [:simple_name]
+end

data/spec/praxis/handlers/xml_spec.rb

@@ -128,7 +128,7 @@ describe Praxis::Handlers::XML do
         it_behaves_like 'xml something'
       end
       context 'a array with elements of all types' do
-        let(:parsed){ ["just text",:a,1,BigDecimal.new(100),0.1,true,Date.new] }
+        let(:parsed){ ["just text",:a,1,BigDecimal(100),0.1,true,Date.new] }
         it_behaves_like 'xml something'
       end
       context 'a hash with a complex substructure' do
@@ -137,7 +137,7 @@ describe Praxis::Handlers::XML do
             "text" => "just text",
             "symbol" => :a,
             "num" => 1,
-            "bd" => BigDecimal.new(100),
+            "bd" => BigDecimal(100),
             "float" => 0.1,
             "truthyness" => true,
             "day" => Date.new,

data/spec/praxis/mapper/resource_spec.rb

@@ -0,0 +1,169 @@
+require '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}
+
+  context 'configuration' do
+    subject(:resource) { SimpleResource }
+    its(:model) { should == model }
+
+    context 'properties' do
+      subject(:properties) { resource.properties }
+
+      it 'includes directly-set properties' do
+        expect(properties[:other_resource]).to eq(dependencies: [:other_model])
+      end
+
+      it 'inherits from a superclass' do
+        expect(properties[:href]).to eq(dependencies: [:id])
+      end
+
+      it 'properly overrides a property from the parent' do
+        expect(properties[:name]).to eq(dependencies: [:simple_name])
+      end
+    end
+  end
+
+  context 'retrieving resources' do
+    context 'getting a single resource' do
+      before do
+       expect(SimpleModel).to receive(:get).with(name: 'george xvi').and_return(record)
+      end
+
+      subject(:resource)  { SimpleResource.get(:name => 'george xvi') }
+
+      it { is_expected.to be_kind_of(SimpleResource) }
+
+      its(:record) { should be record }
+    end
+
+    context 'getting multiple resources' do
+      before do
+        expect(SimpleModel).to receive(:all).with(name: ['george xvi']).and_return([record])
+      end
+
+      subject(:resource_collection) { SimpleResource.all(:name => ["george xvi"]) }
+
+      it { is_expected.to be_kind_of(Array) }
+
+      it 'fetches the models and wraps them' do
+        resource = resource_collection.first
+        expect(resource).to be_kind_of(SimpleResource)
+        expect(resource.record).to eq record
+      end
+    end
+  end
+
+  context 'delegating to the underlying model' do
+
+    subject { SimpleResource.new(record) }
+
+    it 'does respond_to attributes in the model' do
+      expect(subject).to 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"))
+      expect(resource).not_to respond_to(:id)
+    end
+
+    it 'returns raw results for simple attributes' do
+      expect(record).to receive(:name).and_call_original
+      expect(subject.name).to eq("george xvi")
+    end
+
+    it 'wraps model objects in Resource instances' do
+      expect(record).to receive(:parent).and_return(parent_record)
+
+      parent = subject.parent
+
+      expect(parent).to be_kind_of(ParentResource)
+      expect(parent.name).to eq("george sr")
+      expect(parent.record).to eq(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
+        expect(record).to receive(:parents).and_return(parent_records)
+
+        parents = subject.parents
+        expect(parents).to have(parent_records.size).items
+        expect(parents).to be_kind_of(Array)
+
+        parents.each { |parent| expect(parent).to be_kind_of(ParentResource) }
+        expect(parents.collect { |parent| parent.record }).to match_array(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) }
+    
+    it 'delegates to the target' do
+      expect(record).to receive(:other_model).and_return(other_record)
+      expect(resource.other_attribute).to eq(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) }
+
+    subject(:resource) { SimpleResource.new(record) }
+
+    it 'memoizes related resource creation' do
+      allow(record).to receive(:other_model).and_return(other_record)
+      expect(resource.other_resource).to be(SimpleResource.new(record).other_resource)
+    end
+
+  end
+
+
+  context ".wrap" do
+    it 'memoizes resource creation' do
+      expect(SimpleResource.wrap(record)).to be(SimpleResource.wrap(record))
+    end
+
+    it 'works with nil resources, returning an empty set' do
+      wrapped_obj = SimpleResource.wrap(nil)
+      expect(wrapped_obj).to be_kind_of(Array)
+      expect(wrapped_obj.length).to be(0)
+    end
+
+    it 'works array with nil member, returning only existing records' do
+      wrapped_set = SimpleResource.wrap([nil, record])
+      expect(wrapped_set).to be_kind_of(Array)
+      expect(wrapped_set.length).to be(1)
+    end
+    
+    it 'works with non-enumerable objects, that respond to collect' do
+      collectable = double("ArrayProxy", to_a: [record, record] )
+
+      wrapped_set = SimpleResource.wrap(collectable)
+      expect(wrapped_set.length).to be(2)
+    end
+
+    it 'works regardless of the resource class used' do
+      expect(SimpleResource.wrap(record)).to be(OtherResource.wrap(record))
+    end
+  end
+
+end

data/spec/praxis/mapper/selector_generator_spec.rb

@@ -0,0 +1,293 @@
+require 'spec_helper'
+
+
+describe Praxis::Mapper::SelectorGenerator do
+  let(:resource) { SimpleResource }
+  subject(:generator) {described_class.new }
+
+  context '#add' do
+    let(:resource) { SimpleResource }
+    shared_examples 'a proper selector' do
+      it { expect(generator.add(resource, fields).dump).to be_deep_equal selectors }
+    end
+    
+    context 'basic combos' do
+      context 'direct column fields' do
+        let(:fields) { {id: true, foobar: true} }
+        let(:selectors) do 
+          {
+            model: SimpleModel,
+            columns: [:id, :foobar]
+          } 
+        end
+        it_behaves_like 'a proper selector'
+      end
+
+      context 'aliased column fields' do
+        let(:fields) { {id: true, name: true} }
+        let(:selectors) do
+          {
+            model: SimpleModel,
+            columns: [:id, :simple_name]
+          }
+        end
+        it_behaves_like 'a proper selector'
+      end
+
+      context 'pure associations without recursion' do
+        let(:fields) { {other_model: true} }
+        let(:selectors) do
+          {
+            model: SimpleModel,
+            columns: [:other_model_id], # FK of the other_model association
+            tracks: {
+              other_model: { 
+                columns: [:id], # joining key for the association
+                model: OtherModel 
+              }
+            }
+          }
+        end
+        it_behaves_like 'a proper selector'
+      end
+
+      context 'aliased associations without recursion' do
+        let(:fields) { {other_resource: true} }
+        let(:selectors) do
+          {
+            model: SimpleModel,
+            columns: [:other_model_id], # FK of the other_model association
+            tracks: {
+              other_model: { 
+                columns: [:id], # joining key for the association
+                model: OtherModel 
+              }
+            }
+          }
+        end
+        it_behaves_like 'a proper selector'
+      end
+      context 'aliased associations without recursion (that map to columns and other associations)' do
+        let(:fields) { {aliased_method: true} }
+        let(:selectors) do
+          {
+            model: SimpleModel,
+            columns: [:column1, :other_model_id], # other_model_id => because of the association
+            tracks: {
+              other_model: { 
+                columns: [:id], # joining key for the association
+                model: OtherModel 
+              }
+            }
+          }
+        end
+        it_behaves_like 'a proper selector'
+      end
+
+      context 'redefined associations that add some extra columns (would need both the underlying association AND the columns in place)' do
+        let(:fields) { {parent: true} }
+        let(:selectors) do
+          {
+            model: SimpleModel,
+            columns: [:parent_id, :added_column],
+            tracks: {
+              parent: { 
+                columns: [:id],
+                model: ParentModel
+              }
+            }
+          }
+        end
+        it_behaves_like 'a proper selector'
+      end
+
+      context 'a simple property that requires all fields' do
+        let(:fields) { {everything: true} }
+        let(:selectors) do
+          {
+            model: SimpleModel,
+            columns: [:*],
+          }
+        end
+        it_behaves_like 'a proper selector'
+      end
+
+      context 'a simple property that requires itself' do
+        let(:fields) { {circular_dep: true} }
+        let(:selectors) do
+          {
+            model: SimpleModel,
+            columns: [:circular_dep, :column1], #allows to "expand" the dependency into itself + others
+          }
+        end
+        it_behaves_like 'a proper selector'
+      end
+
+      context 'a simple property without dependencies' do
+        let(:fields) { {no_deps: true} }
+        let(:selectors) do
+          {
+            model: SimpleModel
+          }
+        end
+        it_behaves_like 'a proper selector'
+      end
+
+    end
+
+    context 'nested tracking' do
+      context 'pure associations follow the nested fields' do
+        let(:fields) do
+          { 
+            other_model: {
+              id: true
+            }
+          }
+        end
+        let(:selectors) do
+          {
+            model: SimpleModel,
+            columns: [:other_model_id],
+            tracks: {
+              other_model: {
+                model: OtherModel,
+                columns: [:id]
+              }
+            }
+          }
+        end
+        it_behaves_like 'a proper selector'
+      end
+
+      context 'Aliased resources disregard any nested fields...' do
+        let(:fields) do
+          {
+            other_resource: {
+              id: true
+            }
+          }
+        end
+        let(:selectors) do
+          {
+            model: SimpleModel,
+            columns: [:other_model_id],
+            tracks: {
+              other_model: {
+                model: OtherModel,
+                columns: [:id]
+              }
+            }
+          }
+        end
+        it_behaves_like 'a proper selector'
+      end
+    end
+
+    context 'string associations' do
+      context 'that specify a direct existing colum in the target dependency' do
+        let(:fields) { { direct_other_name: true } }
+        let(:selectors) do
+          {
+            model: SimpleModel,
+            columns: [:other_model_id],
+            tracks: {
+              other_model: {
+                model: OtherModel,
+                columns: [:id, :name]
+              }
+            }
+          }
+        end
+        it_behaves_like 'a proper selector'
+      end
+
+      context 'that specify an aliased property in the target dependency' do
+        let(:fields) { { aliased_other_name: true } }
+        let(:selectors) do
+          {
+            model: SimpleModel,
+            columns: [:other_model_id],
+            tracks: {
+              other_model: {
+                model: OtherModel,
+                columns: [:id, :name]
+              }
+            }
+          }
+        end
+        it_behaves_like 'a proper selector'
+      end
+
+      context 'for a property that requires all fields from an association' do
+        let(:fields) { {everything_from_parent: true} }
+        let(:selectors) do
+          {
+            model: SimpleModel,
+            columns: [:parent_id],
+            tracks: {
+              parent: { 
+                model: ParentModel,
+                columns: [:*]
+              }
+            }
+          }
+        end
+        it_behaves_like 'a proper selector'
+      end
+    end
+
+    context 'required extra select fields due to associations' do
+      context 'many_to_one' do
+        let(:fields) { {other_model: true} }
+        let(:selectors) do
+          {
+            model: SimpleModel,
+            columns: [:other_model_id], # FK of the other_model association
+            tracks: {
+              other_model: { 
+                columns: [:id],
+                model: OtherModel 
+              }
+            }
+          }
+        end
+        it_behaves_like 'a proper selector'
+      end
+      context 'one_to_many' do
+        let(:resource) { ParentResource }
+        let(:fields) { {simple_children: true} }
+        let(:selectors) do
+          {
+            model: ParentModel,
+            columns: [:id], # No FKs in the source model for one_to_many
+            tracks: {
+              simple_children: { 
+                columns: [:parent_id],
+                model: SimpleModel 
+              }
+            }
+          }
+        end
+        it_behaves_like 'a proper selector'
+      end      
+      context 'many_to_many' do
+        let(:resource) { OtherResource }
+        let(:fields) { {simple_models: true} }
+        let(:selectors) do
+          {
+            model: OtherModel,
+            columns: [:id], #join key in the source model for many_to_many (where the middle table points to)
+            tracks: {
+              simple_models: { 
+                columns: [:id], #join key in the target model for many_to_many (where the middle table points to)
+                model: SimpleModel
+              }
+            }
+          }
+        end
+        it_behaves_like 'a proper selector'
+      end      
+
+    end
+  end
+end