vorpal 1.0.3 → 1.1.0

data/spec/unit/vorpal/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/unit/vorpal/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

data/spec/unit/vorpal/dsl/config_builder_spec.rb

@@ -1,18 +0,0 @@
-require 'unit_spec_helper'
-
-require 'vorpal/dsl/config_builder'
-
-describe Vorpal::Dsl::ConfigBuilder do
-  class Tester; end
-
-  let(:builder) { Vorpal::Dsl::ConfigBuilder.new(Tester, {}, nil) }
-
-  describe 'mapping attributes' do
-    it 'allows the \'attributes\' method to be called multiple times' do
-      builder.attributes :first
-      builder.attributes :second
-
-      expect(builder.attributes_with_id).to eq([:id, :first, :second])
-    end
-  end
-end

data/spec/unit/vorpal/dsl/defaults_generator_spec.rb

@@ -1,75 +0,0 @@
-require 'unit_spec_helper'
-
-require 'vorpal/dsl/defaults_generator'
-require 'vorpal/driver/postgresql'
-
-describe Vorpal::Dsl::DefaultsGenerator do
-  class Tester; end
-  class Author; end
-  module Namespace
-    class Tester; end
-    class Author; end
-  end
-
-  let(:db_driver) { instance_double(Vorpal::Driver::Postgresql)}
-
-  describe '#build_db_class' do
-    it 'derives the table_name from the domain class name' do
-      generator = build_generator(Tester)
-      expect(db_driver).to receive(:build_db_class).with(Tester, "testers")
-
-      generator.build_db_class(nil)
-    end
-
-    it 'specifies the table_name manually' do
-      generator = build_generator(Tester)
-      expect(db_driver).to receive(:build_db_class).with(Tester, "override")
-
-      generator.build_db_class("override")
-    end
-  end
-
-  describe '#table_name' do
-    it 'namespaces the table name' do
-      generator = build_generator(Namespace::Tester)
-
-      expect(generator.table_name).to eq("namespace/testers")
-    end
-  end
-
-  describe '#child_class' do
-    it 'resolves the associated class' do
-      generator = build_generator(Tester)
-      clazz = generator.child_class("author")
-
-      expect(clazz.name).to eq("Author")
-    end
-
-    it 'resolves the associated class in the same namespace as the owning class' do
-      generator = build_generator(Namespace::Tester)
-      clazz = generator.child_class("author")
-
-      expect(clazz.name).to eq("Namespace::Author")
-    end
-  end
-
-  describe '#foreign_key' do
-    it 'generates a foreign key from an association name' do
-      generator = build_generator(Tester)
-      fk_name = generator.foreign_key("author")
-
-      expect(fk_name).to eq("author_id")
-    end
-
-    it 'generates a foreign key from an association name regardless of the namespace of the owning class' do
-      generator = build_generator(Namespace::Tester)
-      fk_name = generator.foreign_key("author")
-
-      expect(fk_name).to eq("author_id")
-    end
-  end
-
-  def build_generator(domain_clazz)
-    Vorpal::Dsl::DefaultsGenerator.new(domain_clazz, db_driver)
-  end
-end

data/spec/unit/vorpal/identity_map_spec.rb

@@ -1,62 +0,0 @@
-require 'unit_spec_helper'
-
-require 'vorpal/identity_map'
-
-describe Vorpal::IdentityMap do
-  let(:map) { Vorpal::IdentityMap.new }
-
-  it "does not rely on the key object's implementation of hash and eql?" do
-    funny1 = build_funny_entity(1)
-    map.set(funny1, 'funny 1')
-
-    funny2 = build_funny_entity(2)
-    map.set(funny2, 'funny 2')
-
-    expect(map.get(funny1)).to eq('funny 1')
-  end
-
-  it "raises an exception when the key object does not have an id set" do
-    entity = build_entity(nil)
-
-    expect { map.set(entity, 'something') }.to raise_error(/Cannot map a DB row/)
-  end
-
-  it 'raises an exception when the key object extends a class with no name (such as anonymous classes)' do
-    anonymous_class = Class.new do
-      attr_accessor :id
-    end
-
-    entity = anonymous_class.new
-    entity.id = 1
-
-    expect { map.set(entity, 'something') }.to raise_error(/Cannot map a DB row/)
-  end
-
-  def build_entity(id)
-    entity = Entity.new
-    entity.id = id
-    entity
-  end
-
-  class Entity
-    attr_accessor :id
-  end
-
-  def build_funny_entity(id)
-    funny1 = Funny.new
-    funny1.id = id
-    funny1
-  end
-
-  class Funny
-    attr_accessor :id
-
-    def hash
-      1
-    end
-
-    def eql?(other)
-      true
-    end
-  end
-end

data/spec/unit/vorpal/loaded_objects_spec.rb

@@ -1,22 +0,0 @@
-require 'unit_spec_helper'
-
-require 'virtus'
-require 'vorpal/loaded_objects'
-require 'vorpal/configs'
-
-describe Vorpal::LoadedObjects do
-  class TestObject
-    include Virtus.model
-    attribute :id, Integer
-  end
-
-  it 'does not accept duplicate objects' do
-    object = TestObject.new(id: 22)
-    config = Vorpal::ClassConfig.new({domain_class: Object})
-
-    subject.add(config, [object, object])
-    subject.add(config, [object])
-
-    expect(subject.objects.values.flatten).to contain_exactly(object)
-  end
-end

data/spec/unit/vorpal/util/string_utils_spec.rb

@@ -1,25 +0,0 @@
-require 'unit_spec_helper'
-require 'vorpal/util/string_utils'
-
-describe Vorpal::Util::StringUtils do
-
-  describe '.escape_class_name' do
-    it 'does nothing when there are no :: in the class name' do
-      expect(escape_class_name("Foo")).to eq("Foo")
-    end
-
-    it 'converts :: into __' do
-      expect(escape_class_name("Foo::Bar")).to eq("Foo__Bar")
-    end
-
-    it 'converts multiple :: into __' do
-      expect(escape_class_name("Foo::Bar::Baz")).to eq("Foo__Bar__Baz")
-    end
-  end
-
-  private
-
-  def escape_class_name(class_name)
-    Vorpal::Util::StringUtils.escape_class_name(class_name)
-  end
-end

data/spec/unit_spec_helper.rb

@@ -1 +0,0 @@
-require 'helpers/codecov_helper'