vorpal 1.0.0 → 1.2.0

data/spec/vorpal/integration/driver/postgresql_spec.rb

@@ -1,42 +0,0 @@
-require 'integration_spec_helper'
-require 'vorpal'
-
-describe Vorpal::Driver::Postgresql do
-  describe '#build_db_class' do
-    let(:db_class) { subject.build_db_class(PostgresDriverSpec::Foo, 'example') }
-
-    it 'generates a valid class name so that rails auto-reloading works' do
-      expect { Vorpal.const_defined?(db_class.name) }.to_not raise_error
-    end
-
-    it 'does not let the user access the generated class' do
-      expect { Vorpal.const_get(db_class.name) }.to raise_error(NameError)
-    end
-
-    it 'isolates two POROs that map to the same db table' do
-      db_class1 = build_db_class(PostgresDriverSpec::Foo)
-      db_class2 = build_db_class(PostgresDriverSpec::Bar)
-
-      expect(db_class1).to_not eq(db_class2)
-      expect(db_class1.name).to_not eq(db_class2.name)
-    end
-
-    it 'uses the model class name to make the generated AR::Base class name unique' do
-      db_class = build_db_class(PostgresDriverSpec::Foo)
-
-      expect(db_class.name).to match("PostgresDriverSpec__Foo")
-    end
-  end
-
-  private
-
-  module PostgresDriverSpec
-    class Foo; end
-    class Bar; end
-  end
-
-  def build_db_class(clazz)
-    db_driver = Vorpal::Driver::Postgresql.new
-    db_driver.build_db_class(clazz, 'example')
-  end
-end

data/spec/vorpal/performance/performance_spec.rb

@@ -1,195 +0,0 @@
-require 'integration_spec_helper'
-require 'vorpal'
-require 'virtus'
-require 'activerecord-import/base'
-
-module Performance
-describe 'performance' do
-
-  class Bug
-    include Virtus.model
-
-    attribute :id, Integer
-    attribute :name, String
-    attribute :lives_on, Object
-  end
-
-  class Tree; end
-
-  class Trunk
-    include Virtus.model
-
-    attribute :id, Integer
-    attribute :length, Decimal
-    attribute :bugs, Array[Bug]
-    attribute :tree, Tree
-  end
-
-  class Branch
-    include Virtus.model
-
-    attribute :id, Integer
-    attribute :length, Decimal
-    attribute :tree, Tree
-    attribute :branches, Array[Branch]
-    attribute :bugs, Array[Bug]
-
-    def add_branch(branch_options)
-      branch = Branch.new(branch_options.merge(branch: self))
-      branches << branch
-      branch
-    end
-  end
-
-  class Tree
-    include Virtus.model
-
-    attribute :id, Integer
-    attribute :name, String
-    attribute :trunk, Trunk
-    attribute :branches, Array[Branch]
-
-    def set_trunk(trunk)
-      trunk.tree = self
-      self.trunk = trunk
-    end
-
-    def add_branch(branch_options)
-      branch = Branch.new(branch_options.merge(tree: self))
-      branches << branch
-      branch
-    end
-  end
-
-  before(:all) do
-    define_table('branches_perf', {length: :decimal, tree_id: :integer, branch_id: :integer}, false)
-    define_table('bugs_perf', {name: :text, lives_on_id: :integer, lives_on_type: :string}, false)
-    define_table('trees_perf', {name: :text, trunk_id: :integer}, false)
-    define_table('trunks_perf', {length: :decimal}, false)
-  end
-
-  let(:tree_mapper) { build_mapper }
-
-  # Vorpal 0.0.5:
-  #               user     system      total        real
-  # create    4.160000   0.440000   4.600000 (  6.071752)
-  # update    7.990000   0.730000   8.720000 ( 15.281017)
-  # load     10.120000   0.730000  10.850000 ( 21.087785)
-  # destroy   6.090000   0.620000   6.710000 ( 12.541420)
-  #
-  # Vorpal 0.0.6:
-  #               user     system      total        real
-  # create    0.990000   0.100000   1.090000 (  1.415715)
-  # update    2.240000   0.180000   2.420000 (  2.745321)
-  # load      2.130000   0.020000   2.150000 (  2.223182)
-  # destroy   0.930000   0.010000   0.940000 (  1.038624)
-  #
-  # Vorpal 0.1.0:
-  # user     system      total        real
-  # create    0.870000   0.100000   0.970000 (  1.320534)
-  # update    1.820000   0.210000   2.030000 (  2.351518)
-  # load      1.310000   0.010000   1.320000 (  1.394192)
-  # destroy   0.930000   0.010000   0.940000 (  1.030910)
-  it 'benchmarks all operations' do
-    trees = build_trees(1000)
-    Benchmark.bm(7) do |x|
-      x.report('create') { tree_mapper.persist(trees) }
-      x.report('update') { tree_mapper.persist(trees) }
-      x.report('load') { tree_mapper.query.where(id: trees.map(&:id)).load_many }
-      x.report('destroy') { tree_mapper.destroy(trees) }
-    end
-  end
-
-  # it 'creates aggregates quickly' do
-  #   trees = build_trees(1000)
-  #
-  #   puts 'starting persistence benchmark'
-  #   puts Benchmark.measure {
-  #     tree_mapper.persist(trees)
-  #   }
-  # end
-  #
-  # it 'updates aggregates quickly' do
-  #   trees = build_trees(1000)
-  #
-  #   tree_mapper.persist(trees)
-  #
-  #   puts 'starting update benchmark'
-  #   puts Benchmark.measure {
-  #     tree_mapper.persist(trees)
-  #   }
-  # end
-  #
-  # it 'loads aggregates quickly' do
-  #   trees = build_trees(1000)
-  #   tree_mapper.persist(trees)
-  #   ids = trees.map(&:id)
-  #
-  #   puts 'starting loading benchmark'
-  #   puts Benchmark.measure {
-  #     tree_mapper.query.where(id: ids).load_many
-  #   }
-  # end
-  #
-  # it 'destroys aggregates quickly' do
-  #   trees = build_trees(1000)
-  #   tree_mapper.persist(trees)
-  #
-  #   puts 'starting destruction benchmark'
-  #   puts Benchmark.measure {
-  #     tree_mapper.destroy(trees)
-  #   }
-  # end
-
-  def build_trees(count)
-    (1..count).map do |i|
-      tree = Tree.new
-      trunk = Trunk.new(length: i)
-      tree.set_trunk(trunk)
-
-      branch1 = tree.add_branch(length: i * 10)
-      branch2 = tree.add_branch(length: i * 20)
-      branch2.add_branch(length: i * 30)
-
-      build_bug(trunk)
-      build_bug(branch1)
-
-      tree
-    end
-  end
-
-  def build_bug(bug_home)
-    bug = Bug.new(lives_on: bug_home)
-    bug_home.bugs = [bug]
-  end
-
-  def build_mapper
-    engine = Vorpal.define do
-      map Tree, table_name: "trees_perf" do
-        attributes :name
-        belongs_to :trunk
-        has_many :branches
-      end
-
-      map Trunk, table_name: "trunks_perf" do
-        attributes :length
-        has_one :tree
-        has_many :bugs, fk: :lives_on_id, fk_type: :lives_on_type
-      end
-
-      map Branch, table_name: "branches_perf" do
-        attributes :length
-        belongs_to :tree
-        has_many :bugs, fk: :lives_on_id, fk_type: :lives_on_type
-        has_many :branches
-      end
-
-      map Bug, table_name: "bugs_perf" do
-        attributes :name
-        belongs_to :lives_on, fk: :lives_on_id, fk_type: :lives_on_type, child_classes: [Trunk, Branch]
-      end
-    end
-    engine.mapper_for(Tree)
-  end
-end
-end

data/spec/vorpal/unit/configs_spec.rb

@@ -1,117 +0,0 @@
-require 'unit_spec_helper'
-require 'vorpal/configs'
-
-describe Vorpal::MasterConfig do
-  class Post
-    attr_accessor :comments
-    attr_accessor :best_comment
-  end
-
-  class Comment
-    attr_accessor :post
-  end
-
-  let(:post_config) { Vorpal::ClassConfig.new(domain_class: Post) }
-  let(:comment_config) { Vorpal::ClassConfig.new(domain_class: Comment) }
-  let(:post_has_many_comments_config) { Vorpal::HasManyConfig.new(name: 'comments', fk: 'post_id', child_class: Comment) }
-  let(:post_has_one_comment_config) { Vorpal::HasOneConfig.new(name: 'best_comment', fk: 'post_id', child_class: Comment) }
-  let(:comment_belongs_to_post_config) { Vorpal::BelongsToConfig.new(name: 'post', fk: 'post_id', child_classes: [Post]) }
-
-  describe 'local_association_configs' do
-    it 'builds an association_config for a belongs_to' do
-      comment_config.belongs_tos << comment_belongs_to_post_config
-
-      Vorpal::MasterConfig.new([post_config, comment_config])
-
-      expect(comment_config.local_association_configs.size).to eq(1)
-      expect(post_config.local_association_configs.size).to eq(0)
-    end
-
-    it 'sets the association end configs' do
-      comment_config.belongs_tos << comment_belongs_to_post_config
-      post_config.has_manys << post_has_many_comments_config
-
-      Vorpal::MasterConfig.new([post_config, comment_config])
-
-      association_config = comment_config.local_association_configs.first
-
-      expect(association_config.remote_end_config).to eq(post_has_many_comments_config)
-      expect(association_config.local_end_config).to eq(comment_belongs_to_post_config)
-    end
-
-    it 'builds an association_config for a has_many' do
-      post_config.has_manys << post_has_many_comments_config
-
-      Vorpal::MasterConfig.new([post_config, comment_config])
-
-      expect(comment_config.local_association_configs.size).to eq(1)
-      expect(post_config.local_association_configs.size).to eq(0)
-    end
-  end
-
-  describe 'nice user feedback' do
-    it 'lets the user know what the problem is when a configuration is missing' do
-      master_config = Vorpal::MasterConfig.new([])
-
-      expect {
-        master_config.config_for(String)
-      }.to raise_error(Vorpal::ConfigurationNotFound, "No configuration found for String")
-    end
-  end
-
-  describe Vorpal::AssociationConfig do
-    describe 'associate' do
-      let(:post) { Post.new }
-      let(:comment) { Comment.new }
-
-      it 'sets both ends of a one-to-one association' do
-        config = Vorpal::AssociationConfig.new(comment_config, 'post_id', nil)
-        config.add_remote_class_config(post_config)
-
-        config.local_end_config = comment_belongs_to_post_config
-        config.remote_end_config = post_has_one_comment_config
-
-        config.associate(comment, post)
-
-        expect(comment.post).to eq(post)
-        expect(post.best_comment).to eq(comment)
-      end
-
-      it 'sets both ends of a one-to-many association' do
-        config = Vorpal::AssociationConfig.new(comment_config, 'post_id', nil)
-        config.add_remote_class_config(post_config)
-
-        config.local_end_config = comment_belongs_to_post_config
-        config.remote_end_config = post_has_many_comments_config
-
-        config.associate(comment, post)
-
-        expect(comment.post).to eq(post)
-        expect(post.comments).to eq([comment])
-      end
-    end
-
-    describe 'remote_class_config' do
-      it 'works with non-polymorphic associations' do
-        config = Vorpal::AssociationConfig.new(comment_config, 'post_id', nil)
-        config.add_remote_class_config(post_config)
-
-        post = Post.new
-        class_config = config.remote_class_config(post)
-
-        expect(class_config).to eq(post_config)
-      end
-
-      it 'works with polymorphic associations' do
-        config = Vorpal::AssociationConfig.new(comment_config, 'commented_upon_id', 'commented_upon_type')
-        config.add_remote_class_config(post_config)
-        config.add_remote_class_config(comment_config)
-
-        comment = double('comment', commented_upon_type: 'Comment')
-        class_config = config.remote_class_config(comment)
-
-        expect(class_config).to eq(comment_config)
-      end
-    end
-  end
-end

data/spec/vorpal/unit/db_loader_spec.rb

@@ -1,103 +0,0 @@
-require 'unit_spec_helper'
-require 'vorpal'
-require 'virtus'
-
-describe Vorpal::DbLoader do
-
-  class Post; end
-
-  class Comment
-    include Virtus.model
-
-    attribute :id, Integer
-    attribute :post, Post
-  end
-
-  class Post
-    include Virtus.model
-
-    attribute :id, Integer
-    attribute :best_comment, Comment
-    attribute :comments, Array[Comment]
-  end
-
-  class PostDB
-    include Virtus.model
-    attribute :id, Integer
-    attribute :best_comment_id, Integer
-  end
-
-  class CommentDB
-    include Virtus.model
-    attribute :id, Integer
-    attribute :post_id, Integer
-  end
-
-  before(:all) do
-    # define_table('comments', {post_id: :integer}, false)
-    # CommentDB = defineAr('comments')
-
-    # define_table('posts', {best_comment_id: :integer}, false)
-    # PostDB = defineAr('posts')
-  end
-
-  # it 'loads an object once even when referred to by different associations of different types2' do
-  #   post_config = Vorpal.build_class_config(Post) do
-  #     attributes :name
-  #     belongs_to :best_comment, child_class: Comment
-  #     has_many :comments
-  #   end
-  #
-  #   comment_config = Vorpal.build_class_config(Comment) do
-  #     attributes :length
-  #   end
-  #
-  #   master_config = Vorpal::MasterConfig.new([post_config, comment_config])
-  #
-  #   driver = Vorpal::Postgresql.new
-  #
-  #   best_comment_db = CommentDB.create!
-  #   post_db = PostDB.create!(best_comment_id: best_comment_db.id)
-  #   best_comment_db.update_attributes!(post_id: post_db.id)
-  #
-  #   loader = Vorpal::DbLoader.new(false, driver)
-  #   loaded_objects = loader.load_from_db([post_db.id], master_config.config_for(Post))
-  #   p loaded_objects.all_objects
-  #   # expect(loaded_objects.all_objects.size).to eq(2)
-  #
-  #   repo = Vorpal::AggregateMapper.new(driver, master_config)
-  #   post = repo.load(post_db.id, Post)
-  #   p post
-  #   expect(post.comments.size).to eq(1)
-  # end
-
-  it 'loads an object once even when referred to by different associations of different types with stubs' do
-    post_config = Vorpal.build_class_config(Post, to: PostDB) do
-      attributes :name
-      belongs_to :best_comment, child_class: Comment
-      has_many :comments
-    end
-
-    comment_config = Vorpal.build_class_config(Comment, to: CommentDB) do
-      attributes :length
-    end
-
-    Vorpal::MasterConfig.new([post_config, comment_config])
-
-    best_comment_db = CommentDB.new
-    best_comment_db.id = 99
-    post_db = PostDB.new(best_comment_id: best_comment_db.id)
-    post_db.id = 100
-    best_comment_db.post_id = post_db.id
-
-    driver = instance_double("Vorpal::Driver::Postgresql")
-    expect(driver).to receive(:load_by_id).with(PostDB, [post_db.id]).and_return([post_db])
-    expect(driver).to receive(:load_by_id).with(CommentDB, [best_comment_db.id]).and_return([best_comment_db])
-    expect(driver).to receive(:load_by_foreign_key).and_return([best_comment_db])
-
-    loader = Vorpal::DbLoader.new(false, driver)
-    loaded_objects = loader.load_from_db([post_db.id], post_config)
-
-    expect(loaded_objects.all_objects).to contain_exactly(post_db, best_comment_db)
-  end
-end