amoeba 3.3.0 → 3.4.1

data/spec/lib/amoeba_spec.rb

@@ -1,418 +0,0 @@
-require 'spec_helper'
-
-describe 'amoeba' do
-  context 'dup' do
-    before do
-      require ::File.dirname(__FILE__) + '/../support/data.rb'
-    end
-
-    let(:first_product) { Product.find(1) }
-
-    it 'duplicates associated child records' do
-      # Posts {{{
-      old_post = ::Post.find(1)
-      expect(old_post.comments.map(&:contents).include?('I love it!')).to be_truthy
-
-      old_post.class.amoeba do
-        prepend contents: "Here's a copy: "
-      end
-
-      new_post = old_post.amoeba_dup
-
-      start_account_count = Account.all.count
-      start_history_count = History.all.count
-      start_cat_count = Category.all.count
-      start_supercat_count = Supercat.all.count
-      start_tag_count = Tag.all.count
-      start_note_count = Note.all.count
-      start_widget_count = Widget.all.count
-      start_post_count = Post.all.count
-      start_comment_count = Comment.all.count
-      start_rating_count = Rating.all.count
-      start_postconfig_count = PostConfig.all.count
-      start_postwidget_count = PostWidget.all.count
-      start_superkitten_count = Superkitten.all.count
-      start_posttag_count = Post.tag_count
-      start_postnote_count = Post.note_count
-
-      expect(new_post.save!).to be_truthy
-      expect(new_post.title).to eq("Copy of #{old_post.title}")
-
-      end_account_count = Account.count
-      end_history_count = History.count
-      end_cat_count = Category.count
-      end_supercat_count = Supercat.count
-      end_tag_count = Tag.all.count
-      end_note_count = Note.all.count
-      end_widget_count = Widget.all.count
-      end_post_count = Post.all.count
-      end_comment_count = Comment.all.count
-      end_rating_count = Rating.all.count
-      end_postconfig_count = PostConfig.all.count
-      end_postwidget_count = PostWidget.all.count
-      end_superkitten_count = Superkitten.all.count
-      end_posttag_count = Post.tag_count
-      end_postnote_count = Post.note_count
-
-      expect(end_tag_count).to         eq(start_tag_count)
-      expect(end_cat_count).to         eq(start_cat_count)
-      expect(end_account_count).to     eq(start_account_count * 2)
-      expect(end_history_count).to     eq(start_history_count * 2)
-      expect(end_supercat_count).to    eq(start_supercat_count * 2)
-      expect(end_post_count).to        eq(start_post_count * 2)
-      expect(end_comment_count).to     eq((start_comment_count * 2) + 2)
-      expect(end_rating_count).to      eq(start_rating_count * 2)
-      expect(end_postconfig_count).to  eq(start_postconfig_count * 2)
-      expect(end_posttag_count).to     eq(start_posttag_count * 2)
-      expect(end_widget_count).to      eq(start_widget_count * 2)
-      expect(end_postwidget_count).to  eq(start_postwidget_count * 2)
-      expect(end_note_count).to        eq(start_note_count * 2)
-      expect(end_postnote_count).to    eq(start_postnote_count * 2)
-      expect(end_superkitten_count).to eq(start_superkitten_count * 2)
-
-      expect(new_post.supercats.map(&:ramblings)).to include('Copy of zomg')
-      expect(new_post.supercats.map(&:other_ramblings).uniq.length).to eq(1)
-      expect(new_post.supercats.map(&:other_ramblings).uniq).to include('La la la')
-      expect(new_post.contents).to eq("Here's a copy: #{old_post.contents.gsub(/dog/,
-                                                                               'cat')} (copied version)")
-      expect(new_post.comments.length).to eq(5)
-      expect(new_post.comments.select do |c|
-               c.nerf == 'ratatat' && c.contents.nil?
-             end.length).to eq(1)
-      expect(new_post.comments.select { |c| c.nerf == 'ratatat' }.length).to eq(2)
-      expect(new_post.comments.select { |c| c.nerf == 'bonk' }.length).to eq(1)
-      expect(new_post.comments.select do |c|
-               c.nerf == 'bonkers' && c.contents.nil?
-             end.length).to eq(1)
-
-      new_post.widgets.map(&:id).each do |id|
-        expect(old_post.widgets.map(&:id)).not_to include(id)
-      end
-
-      expect(new_post.custom_things.length).to eq(3)
-      expect(new_post.custom_things.select { |ct| ct.value == [] }.length).to eq(1)
-      expect(new_post.custom_things.select { |ct| ct.value == [1, 2] }.length).to eq(1)
-      expect(new_post.custom_things.select { |ct| ct.value == [78] }.length).to eq(1)
-      # }}}
-      # Author {{{
-      old_author = Author.find(1)
-      new_author = old_author.amoeba_dup
-      new_author.save!
-      expect(new_author.errors.messages).to be_empty
-      expect(new_author.posts.first.custom_things.length).to eq(3)
-      expect(new_author.posts.first.custom_things.select { |ct| ct.value == [] }.length).to eq(1)
-      expect(new_author.posts.first.custom_things.select do |ct|
-               ct.value == [1, 2]
-             end.length).to eq(1)
-      expect(new_author.posts.first.custom_things.select { |ct| ct.value == [78] }.length).to eq(1)
-      # }}}
-      # Products {{{
-      # Base Class {{{
-
-      start_image_count = first_product.images.count
-      start_section_count = Section.all.length
-      start_prodsection_count = first_product.section_count
-
-      new_product = first_product.amoeba_dup
-      new_product.save
-      expect(new_product.errors.messages).to be_empty
-
-      end_image_count = first_product.images.count
-      end_newimage_count = new_product.images.count
-      end_section_count = Section.all.length
-      end_prodsection_count = first_product.section_count
-      end_newprodsection_count = new_product.section_count
-
-      expect(end_image_count).to eq(start_image_count)
-      expect(end_newimage_count).to eq(start_image_count)
-      expect(end_section_count).to eq(start_section_count)
-      expect(end_prodsection_count).to eq(start_prodsection_count)
-      expect(end_newprodsection_count).to eq(start_prodsection_count)
-      # }}}
-
-      # Inherited Class {{{
-      # Shirt {{{
-      old_product = Shirt.find(2)
-
-      start_image_count = old_product.images.count
-      start_section_count = Section.count
-      start_prodsection_count = old_product.section_count
-
-      new_product = old_product.amoeba_dup
-      new_product.save
-      expect(new_product.errors.messages).to be_empty
-
-      end_image_count = old_product.images.count
-      end_newimage_count = new_product.images.count
-      end_section_count = Section.count
-      end_prodsection_count = first_product.section_count
-      end_newprodsection_count = new_product.section_count
-
-      expect(end_image_count).to eq(start_image_count)
-      expect(end_newimage_count).to eq(start_image_count)
-      expect(end_section_count).to eq(start_section_count)
-      expect(end_prodsection_count).to eq(start_prodsection_count)
-      expect(end_newprodsection_count).to eq(start_prodsection_count)
-      # }}}
-
-      # Necklace {{{
-      old_product = Necklace.find(3)
-
-      start_image_count = old_product.images.count
-      start_section_count = Section.count
-      start_prodsection_count = old_product.section_count
-
-      new_product = old_product.amoeba_dup
-      new_product.save
-      expect(new_product.errors.messages).to be_empty
-
-      end_image_count = old_product.images.count
-      end_newimage_count = new_product.images.count
-      end_section_count = Section.count
-      end_prodsection_count = first_product.section_count
-      end_newprodsection_count = new_product.section_count
-
-      expect(end_image_count).to eq(start_image_count)
-      expect(end_newimage_count).to eq(start_image_count)
-      expect(end_section_count).to eq(start_section_count)
-      expect(end_prodsection_count).to eq(start_prodsection_count)
-      expect(end_newprodsection_count).to eq(start_prodsection_count)
-      # }}}
-      # }}}
-      # }}}
-    end
-  end
-
-  context 'Using a if condition' do
-    subject { post.amoeba_dup.save! }
-
-    before(:all) do
-      require ::File.dirname(__FILE__) + '/../support/data.rb'
-    end
-
-    before { ::Post.fresh_amoeba }
-
-    let(:post) { Post.first }
-
-    it 'includes an association with truthy condition' do
-      ::Post.amoeba do
-        include_association :comments, if: :truthy?
-      end
-      expect { subject }.to change(Comment, :count).by(3)
-    end
-
-    it 'does not include an association with a falsey condition' do
-      ::Post.amoeba do
-        include_association :comments, if: :falsey?
-      end
-      expect { subject }.not_to change(Comment, :count)
-    end
-
-    it 'excludes an association with a truthy condition' do
-      ::Post.amoeba do
-        exclude_association :comments, if: :truthy?
-      end
-      expect { subject }.not_to change(Comment, :count)
-    end
-
-    it 'does not exclude an association with a falsey condition' do
-      ::Post.amoeba do
-        exclude_association :comments, if: :falsey?
-      end
-      expect { subject }.to change(Comment, :count).by(3)
-    end
-
-    it 'includes associations from a given array with a truthy condition' do
-      ::Post.amoeba do
-        include_association [:comments], if: :truthy?
-      end
-      expect { subject }.to change(Comment, :count).by(3)
-    end
-
-    it 'does not include associations from a given array with a falsey condition' do
-      ::Post.amoeba do
-        include_association [:comments], if: :falsey?
-      end
-      expect { subject }.not_to change(Comment, :count)
-    end
-
-    it 'does exclude associations from a given array with a truthy condition' do
-      ::Post.amoeba do
-        exclude_association [:comments], if: :truthy?
-      end
-      expect { subject }.not_to change(Comment, :count)
-    end
-
-    it 'does not exclude associations from a given array with a falsey condition' do
-      ::Post.amoeba do
-        exclude_association [:comments], if: :falsey?
-      end
-      expect { subject }.to change(Comment, :count).by(3)
-    end
-  end
-
-  context 'override' do
-    before do
-      ::Image.fresh_amoeba
-      ::Image.amoeba do
-        override ->(old, new) { new.product_id = 13 if old.filename == 'test.jpg' }
-      end
-    end
-
-    it 'overrides fields' do
-      image = ::Image.create(filename: 'test.jpg', product_id: 12)
-      image_dup = image.amoeba_dup
-      expect(image_dup.save).to be_truthy
-      expect(image_dup.product_id).to eq(13)
-    end
-
-    it 'does not override fields' do
-      image = ::Image.create(filename: 'test2.jpg', product_id: 12)
-      image_dup = image.amoeba_dup
-      expect(image_dup.save).to be_truthy
-      expect(image_dup.product_id).to eq(12)
-    end
-  end
-
-  context 'nullify' do
-    before do
-      ::Image.fresh_amoeba
-      ::Image.amoeba do
-        nullify :product_id
-      end
-    end
-
-    let(:image) { ::Image.create(filename: 'test.jpg', product_id: 12) }
-    let(:image_dup) { image.amoeba_dup }
-
-    it 'nullifies fields' do
-      expect(image_dup.save).to be_truthy
-      expect(image_dup.product_id).to be_nil
-    end
-  end
-
-  context 'strict propagate' do
-    it 'calls #reset_amoeba' do
-      expect(::SuperBlackBox).to receive(:reset_amoeba).and_call_original
-      box = ::SuperBlackBox.create(title: 'Super Black Box', price: 9.99, length: 1, metal: '1')
-      new_box = box.amoeba_dup
-      expect(new_box.save).to be_truthy
-    end
-  end
-
-  context 'remapping and custom dup method' do
-    let(:prototype) { ObjectPrototype.new }
-
-    context 'through' do
-      it do
-        real_object = prototype.amoeba_dup
-        expect(real_object).to be_a(::RealObject)
-      end
-    end
-
-    context 'remapper' do
-      it do
-        prototype.subobject_prototypes << SubobjectPrototype.new
-        real_object = prototype.amoeba_dup
-        expect(real_object.subobjects.length).to eq(1)
-      end
-    end
-  end
-
-  context 'preprocessing fields' do
-    subject { super_admin.amoeba_dup }
-
-    let(:super_admin) do
-      ::SuperAdmin.create!(email: 'user@example.com', active: true, password: 'password')
-    end
-
-    it 'accepts "set" to set false to attribute' do
-      expect(subject.active).to be false
-    end
-
-    it 'skips "prepend" if it equal to false' do
-      expect(subject.password).to eq('password')
-    end
-  end
-
-  context 'inheritance' do
-    let(:box) { Box.create }
-
-    it 'does not fail with a deep inheritance' do
-      sub_sub_product = BoxSubSubProduct.create(title: 'Awesome shoes')
-      another_product = BoxAnotherProduct.create(title: 'Cleaning product')
-      sub_sub_product.update(box: box, another_product: another_product)
-      expect(box.sub_products.first.another_product.title).to eq('Cleaning product')
-      expect(box.amoeba_dup.sub_products.first.another_product.title).to eq('Cleaning product')
-    end
-  end
-
-  context 'inheritance extended' do
-    subject { stage.amoeba_dup }
-
-    let(:stage) do
-      stage = CustomStage.new(title: 'My Stage', external_id: 213)
-      stage.listeners.build(name: 'John')
-      stage.listeners.build(name: 'Helen')
-      stage.specialists.build(name: 'Jack')
-      stage.custom_rules.build(description: 'Kill all humans')
-      stage.save!
-      stage
-    end
-
-    it 'contains parent association and own associations', :aggregate_failures do
-      subject
-      expect { subject.save! }.to change(Listener, :count).by(2)
-                                                          .and change(Specialist, :count).by(1)
-                                                                                         .and change(
-                                                                                           CustomRule, :count
-                                                                                         ).by(1)
-
-      expect(subject.title).to eq 'My Stage'
-      expect(subject.external_id).to be_nil
-      expect(subject.listeners.find_by(name: 'John')).not_to be_nil
-      expect(subject.listeners.find_by(name: 'Helen')).not_to be_nil
-      expect(subject.specialists.find_by(name: 'Jack')).not_to be_nil
-      expect(subject.custom_rules.first.description).to eq 'Kill all humans'
-    end
-  end
-
-  context 'polymorphic' do
-    let(:company) { Company.find_by(name: 'ABC Industries') }
-    let(:new_company) { company.amoeba_dup }
-
-    it 'does not fail with a deep inheritance' do
-      # employee = company.employees.where(name:'Joe').first
-      start_company_count = Company.count
-      start_customer_count = Customer.count
-      start_employee_count = Employee.count
-      start_address_count = Address.count
-      start_photo_count = Photo.count
-      new_company.name = "Copy of #{new_company.name}"
-      new_company.save
-      expect(Company.count).to eq(start_company_count + 1)
-      expect(Customer.count).to eq(start_customer_count + 1)
-      expect(Employee.count).to eq(start_employee_count + 1)
-      expect(Address.count).to eq(start_address_count + 4)
-      expect(Photo.count).to eq(start_photo_count + 2)
-
-      new_company.reload # fully reload from database
-      new_company_employees = new_company.employees
-      expect(new_company_employees.count).to eq(1)
-      new_company_employee_joe = new_company_employees.find_by(name: 'Joe')
-      expect(new_company_employee_joe.photos.count).to eq(1)
-      expect(new_company_employee_joe.photos.first.size).to eq(12_345)
-      expect(new_company_employee_joe.addresses.count).to eq(2)
-      expect(new_company_employee_joe.addresses.where(street: '123 My Street').count).to eq(1)
-      expect(new_company_employee_joe.addresses.where(street: '124 My Street').count).to eq(1)
-      new_company_customers = new_company.customers
-      expect(new_company_customers.count).to eq(1)
-      new_company_customer_my = new_company_customers.where(email: 'my@email.address').first
-      expect(new_company_customer_my.photos.count).to eq(1)
-      expect(new_company_customer_my.photos.first.size).to eq(54_321)
-      expect(new_company_customer_my.addresses.count).to eq(2)
-      expect(new_company_customer_my.addresses.where(street: '321 My Street').count).to eq(1)
-      expect(new_company_customer_my.addresses.where(street: '321 My Drive').count).to eq(1)
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,37 +0,0 @@
-require 'simplecov'
-
-SimpleCov.start do
-  add_filter 'spec'
-  minimum_coverage(76)
-
-  if ENV['CI']
-    require 'simplecov-lcov'
-
-    SimpleCov::Formatter::LcovFormatter.config do |c|
-      c.report_with_single_file = true
-      c.single_report_path = 'coverage/lcov.info'
-    end
-
-    formatter SimpleCov::Formatter::LcovFormatter
-  end
-end
-
-require 'active_record'
-require 'amoeba'
-
-adapter = if defined?(JRuby)
-            require 'activerecord-jdbcsqlite3-adapter'
-            'jdbcsqlite3'
-          else
-            require 'sqlite3'
-            'sqlite3'
-          end
-
-ActiveRecord::Base.establish_connection(adapter: adapter, database: ':memory:')
-
-::RSpec.configure do |config|
-  config.order = :default
-end
-
-load File.dirname(__FILE__) + '/support/schema.rb'
-load File.dirname(__FILE__) + '/support/models.rb'

data/spec/support/data.rb

@@ -1,106 +0,0 @@
-u1 = User.create(name: 'Robert Johnson', email: 'bob@crossroads.com')
-u2 = User.create(name: 'Miles Davis', email: 'miles@kindofblue.com')
-
-a1 = Author.create(full_name: 'Kermit The Vonnegut', nickname: 'kvsoitgoes')
-a2 = Author.create(full_name: 'Arthur Sees Clarck', nickname: 'strangewater')
-
-t = Topic.create(title: 'Ponies', description: 'Lets talk about my ponies.')
-
-# First Post {{{
-p1 = t.posts.create(owner: u1, author: a1, title: 'My little pony',
-                    contents: 'Lorum ipsum dolor rainbow bright. I like dogs, dogs are awesome.')
-f1 = p1.create_post_config(is_visible: true, is_open: false, password: 'abcdefg123')
-a1 = p1.create_account(title: 'Foo')
-h1 = p1.account.create_history(some_stuff: 'Bar')
-c1 = p1.comments.create(contents: 'I love it!', nerf: 'ratatat')
-[5, 5, 4, 3, 5, 5].each { |stars| c1.ratings.create(num_stars: stars) }
-
-c2 = p1.comments.create(contents: 'I hate it!', nerf: 'whapaow')
-[3, 1, 4, 1, 1, 2].each { |stars| c2.ratings.create(num_stars: stars) }
-
-c3 = p1.comments.create(contents: 'kthxbbq!!11!!!1!eleven!!', nerf: 'bonk')
-[0, 0, 1, 2, 1, 0].each { |stars| c3.ratings.create(num_stars: stars) }
-
-%w[funny wtf cats].each { |value| p1.tags << Tag.create(value: value) }
-
-['My Sidebar', 'Photo Gallery', 'Share & Like'].each do |value|
-  p1.widgets << Widget.create(value: value)
-end
-
-['This is important', "You've been warned", "Don't forget"].each do |value|
-  p1.notes << Note.create(value: value)
-end
-
-p1.save
-
-c1 = Category.create(title: 'Umbrellas', description: 'Clown fart')
-c2 = Category.create(title: 'Widgets', description: 'Humpty dumpty')
-c3 = Category.create(title: 'Wombats', description: 'Slushy mushy')
-
-s1 = Supercat.create(post: p1, category: c1, ramblings: 'zomg', other_ramblings: 'nerp')
-s2 = Supercat.create(post: p1, category: c2, ramblings: 'why', other_ramblings: 'narp')
-s3 = Supercat.create(post: p1, category: c3, ramblings: 'ohnoes', other_ramblings: 'blap')
-
-s1.superkittens.create(value: 'Fluffy')
-s1.superkittens.create(value: 'Buffy')
-s1.superkittens.create(value: 'Fuzzy')
-
-s2.superkittens.create(value: 'Hairball')
-s2.superkittens.create(value: 'Crosseye')
-s2.superkittens.create(value: 'Spot')
-
-s3.superkittens.create(value: 'Dopey')
-s3.superkittens.create(value: 'Sneezy')
-s3.superkittens.create(value: 'Sleepy')
-
-p1.custom_things.create([{ value: [1, 2] }, { value: [] }, { value: [78] }])
-# }}}
-
-# Product {{{
-product1 = Product.create(title: 'Sticky Notes 5-Pak', price: 5.99, weight: 0.56)
-shirt1 = Shirt.create(title: 'Fancy Shirt', price: 48.95, sleeve: 32, collar: 15.5)
-necklace1 = Necklace.create(title: 'Pearl Necklace', price: 2995.99, length: 18, metal: '14k')
-
-img1 = product1.images.create(filename: 'sticky.jpg')
-img2 = product1.images.create(filename: 'notes.jpg')
-
-img1 = shirt1.images.create(filename: '02948u31.jpg')
-img2 = shirt1.images.create(filename: 'zsif8327.jpg')
-
-img1 = necklace1.images.create(filename: 'ae02x9f1.jpg')
-img2 = necklace1.images.create(filename: 'cba9f912.jpg')
-
-office = Section.create(name: 'Office', num_employees: 2, total_sales: '1234.56')
-supplies = Section.create(name: 'Supplies', num_employees: 1, total_sales: '543.21')
-mens = Section.create(name: 'Mens', num_employees: 3, total_sales: '11982.63')
-apparel = Section.create(name: 'Apparel', num_employees: 5, total_sales: '1315.20')
-accessories = Section.create(name: 'Accessories', num_employees: 1, total_sales: '8992.34')
-jewelry = Section.create(name: 'Jewelry', num_employees: 3, total_sales: '25481.77')
-
-product1.sections << office
-product1.sections << supplies
-product1.save
-
-shirt1.sections << mens
-shirt1.sections << apparel
-shirt1.save
-
-necklace1.sections << jewelry
-necklace1.sections << accessories
-necklace1.save
-
-company = Company.create(name: 'ABC Industries')
-employee = company.employees.create(name: 'Joe', ssn: '1111111111', salary: 10_000.0)
-employee_address = employee.addresses.create(street: '123 My Street', unit: '103', city: 'Hollywood',
-                                             state: 'CA', zip: '90210')
-employee_address_2 = employee.addresses.create(street: '124 My Street', unit: '103', city: 'Follywood',
-                                               state: 'CA', zip: '90210')
-employee_photo = employee.photos.create(name: 'Portrait', size: 12_345)
-customer = company.customers.create(email: 'my@email.address', password: 'password')
-customer_address = customer.addresses.create(street: '321 My Street', unit: '301', city: 'Bollywood',
-                                             state: 'IN', zip: '11111')
-customer_address_2 = customer.addresses.create(street: '321 My Drive', unit: '311', city: 'Mollywood',
-                                               state: 'IN', zip: '21111')
-customer_photo = customer.photos.create(name: 'Mug Shot', size: 54_321)
-
-# }}}