From 5efa4c1c055bd668afb836bfb3b80688073e6848 Mon Sep 17 00:00:00 2001 From: Rafael Martins Date: Sat, 5 May 2012 00:12:50 -0300 Subject: [PATCH] Updated unit tests --- test/unit/article_test.rb | 167 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++--------------------------------------------------- test/unit/category_test.rb | 82 +++++++++++++++++++++++++++++++++++++++++++++++++++++++--------------------------- test/unit/certifier_test.rb | 16 ++++++++++++++++ test/unit/enterprise_test.rb | 22 ++++++++++++++++------ test/unit/location_block_test.rb | 8 +++++++- test/unit/product_category_test.rb | 11 ++++++++++- test/unit/product_test.rb | 331 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++------------------------------------------------------------------------- test/unit/profile_test.rb | 104 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++---------------------------------------- test/unit/qualifier_test.rb | 7 +++++++ test/unit/set_profile_region_from_city_state_test.rb | 33 +++++++++++++++++++++++++++++++++ 10 files changed, 582 insertions(+), 199 deletions(-) diff --git a/test/unit/article_test.rb b/test/unit/article_test.rb index c3a0b67..19511ed 100644 --- a/test/unit/article_test.rb +++ b/test/unit/article_test.rb @@ -412,8 +412,8 @@ class ArticleTest < ActiveSupport::TestCase assert_includes c2.articles(true), art assert_includes c1.articles(true), art - assert_includes art.categories_including_virtual(true), c2 - assert_includes art.categories_including_virtual(true), c1 + assert_includes art.categories_including_virtual(true), c2 + assert_includes art.categories_including_virtual(true), c1 end should 'redefine the entire category set at once' do @@ -429,8 +429,8 @@ class ArticleTest < ActiveSupport::TestCase art.category_ids = [c2,c3].map(&:id) assert_equivalent [c2, c3], art.categories(true) - assert_includes art.categories_including_virtual(true), c1 - assert !art.categories_including_virtual(true).include?(c4) + assert_includes art.categories_including_virtual(true), c1 + assert !art.categories_including_virtual(true).include?(c4) end should 'be able to create an article already with categories' do @@ -442,7 +442,7 @@ class ArticleTest < ActiveSupport::TestCase a = p.articles.create!(:name => 'test', :category_ids => [c1.id, c2.id]) assert_equivalent [c1, c2], a.categories(true) - assert_includes a.categories_including_virtual(true), parent1 + assert_includes a.categories_including_virtual(true), parent1 end should 'not add a category twice to article' do @@ -1658,67 +1658,132 @@ class ArticleTest < ActiveSupport::TestCase assert_equal [c1,c2,c5], Article.text_articles end + should 'delegate region info to profile' do + profile = fast_create(Profile) + Profile.any_instance.expects(:region) + Profile.any_instance.expects(:region_id) + article = fast_create(Article, :profile_id => profile.id) + article.region + article.region_id + end + + should 'delegate environment info to profile' do + profile = fast_create(Profile) + Profile.any_instance.expects(:environment) + Profile.any_instance.expects(:environment_id) + article = fast_create(Article, :profile_id => profile.id) + article.environment + article.environment_id + end + should 'act as faceted' do person = fast_create(Person) - a = Article.new(:profile_id => person.id) - assert_equal Article.type_name, Article.facet_by_id(:f_type)[:proc].call(a.send(:f_type)) - assert_equal Person.type_name, Article.facet_by_id(:f_profile_type)[:proc].call(a.send(:f_profile_type)) - assert_equal a.published_at, a.send(:f_published_at) + cat = Category.create!(:name => 'hardcore', :environment_id => Environment.default.id) + a = Article.create!(:name => 'black flag review', :profile_id => person.id) + a.add_category(cat, true) + a.save! + assert_equal Article.type_name, Article.facet_by_id(:f_type)[:proc].call(a.send(:f_type)) + assert_equal Person.type_name, Article.facet_by_id(:f_profile_type)[:proc].call(a.send(:f_profile_type)) + assert_equal a.published_at, a.send(:f_published_at) + assert_equal ['hardcore'], a.send(:f_category) + assert_equal "category_filter:\"#{cat.id}\"", Article.facet_category_query.call(cat) end should 'act as searchable' do person = fast_create(Person, :name => "Hiro", :address => 'U-Stor-It @ Inglewood, California', - :nickname => 'Protagonist') - person2 = fast_create(Person, :name => "Raven") - category = fast_create(Category, :name => "science fiction", :acronym => "sf", :abbreviation => "sci-fi") - a = Article.create!(:name => 'a searchable article about bananas', :profile_id => person.id, - :body => 'the body talks about mosquitos', :abstract => 'and the abstract is about beer', - :filename => 'not_a_virus.exe') - a.add_category(category) - c = a.comments.build(:title => 'snow crash', :author => person2, :body => 'wanna try some?') - c.save! - - # fields - assert_includes Article.find_by_contents('bananas')[:results].docs, a - assert_includes Article.find_by_contents('mosquitos')[:results].docs, a - assert_includes Article.find_by_contents('beer')[:results].docs, a - assert_includes Article.find_by_contents('not_a_virus.exe')[:results].docs, a - # filters - assert_includes Article.find_by_contents('bananas', {}, { - :filter_queries => ["public:true"]})[:results].docs, a - assert_not_includes Article.find_by_contents('bananas', {}, { - :filter_queries => ["public:false"]})[:results].docs, a - assert_includes Article.find_by_contents('bananas', {}, { - :filter_queries => ["environment_id:\"#{Environment.default.id}\""]})[:results].docs, a - assert_includes Article.find_by_contents('bananas', {}, { - :filter_queries => ["profile_id:\"#{person.id}\""]})[:results].docs, a + :nickname => 'Protagonist') + person2 = fast_create(Person, :name => "Raven") + category = fast_create(Category, :name => "science fiction", :acronym => "sf", :abbreviation => "sci-fi") + a = Article.create!(:name => 'a searchable article about bananas', :profile_id => person.id, + :body => 'the body talks about mosquitos', :abstract => 'and the abstract is about beer', + :filename => 'not_a_virus.exe') + a.add_category(category) + c = a.comments.build(:title => 'snow crash', :author => person2, :body => 'wanna try some?') + c.save! + + # fields + assert_includes Article.find_by_contents('bananas')[:results].docs, a + assert_includes Article.find_by_contents('mosquitos')[:results].docs, a + assert_includes Article.find_by_contents('beer')[:results].docs, a + assert_includes Article.find_by_contents('not_a_virus.exe')[:results].docs, a + # filters + assert_includes Article.find_by_contents('bananas', {}, {:filter_queries => ["public:true"]})[:results].docs, a + assert_not_includes Article.find_by_contents('bananas', {}, {:filter_queries => ["public:false"]})[:results].docs, a + assert_includes Article.find_by_contents('bananas', {}, {:filter_queries => ["environment_id:\"#{Environment.default.id}\""]})[:results].docs, a + assert_includes Article.find_by_contents('bananas', {}, {:filter_queries => ["profile_id:\"#{person.id}\""]})[:results].docs, a # includes - assert_includes Article.find_by_contents('Hiro')[:results].docs, a - assert_includes Article.find_by_contents("person-#{person.id}")[:results].docs, a - assert_includes Article.find_by_contents("California")[:results].docs, a - assert_includes Article.find_by_contents("Protagonist")[:results].docs, a - assert_includes Article.find_by_contents("snow")[:results].docs, a - assert_includes Article.find_by_contents("try some")[:results].docs, a - assert_includes Article.find_by_contents("Raven")[:results].docs, a - assert_includes Article.find_by_contents("science")[:results].docs, a - assert_includes Article.find_by_contents(category.slug)[:results].docs, a - assert_includes Article.find_by_contents("sf")[:results].docs, a - assert_includes Article.find_by_contents("sci-fi")[:results].docs, a + assert_includes Article.find_by_contents('Hiro')[:results].docs, a + assert_includes Article.find_by_contents("person-#{person.id}")[:results].docs, a + assert_includes Article.find_by_contents("California")[:results].docs, a + assert_includes Article.find_by_contents("Protagonist")[:results].docs, a + assert_includes Article.find_by_contents("snow")[:results].docs, a + assert_includes Article.find_by_contents("try some")[:results].docs, a + assert_includes Article.find_by_contents("Raven")[:results].docs, a + assert_includes Article.find_by_contents("science")[:results].docs, a + assert_includes Article.find_by_contents(category.slug)[:results].docs, a + assert_includes Article.find_by_contents("sf")[:results].docs, a + assert_includes Article.find_by_contents("sci-fi")[:results].docs, a end should 'boost name matches' do person = fast_create(Person) - in_body = Article.create!(:name => 'something', :profile_id => person.id, :body => 'bananas in the body!') - in_name = Article.create!(:name => 'bananas in the name!', :profile_id => person.id) - assert_equal [in_name, in_body], Article.find_by_contents('bananas')[:results].docs + in_body = Article.create!(:name => 'something', :profile_id => person.id, :body => 'bananas in the body!') + in_name = Article.create!(:name => 'bananas in the name!', :profile_id => person.id) + assert_equal [in_name, in_body], Article.find_by_contents('bananas')[:results].docs end should 'boost if profile is enabled' do person2 = fast_create(Person, :enabled => false) - art_profile_disabled = Article.create!(:name => 'profile disabled', :profile_id => person2.id) + art_profile_disabled = Article.create!(:name => 'profile disabled', :profile_id => person2.id) person1 = fast_create(Person, :enabled => true) - art_profile_enabled = Article.create!(:name => 'profile enabled', :profile_id => person1.id) - assert_equal [art_profile_enabled, art_profile_disabled], Article.find_by_contents('profile')[:results].docs - end + art_profile_enabled = Article.create!(:name => 'profile enabled', :profile_id => person1.id) + assert_equal [art_profile_enabled, art_profile_disabled], Article.find_by_contents('profile')[:results].docs + end + + should 'remove all categorizations when destroyed' do + art = Article.create!(:name => 'article 1', :profile_id => fast_create(Person).id) + cat = Category.create!(:name => 'category 1', :environment_id => Environment.default.id) + art.add_category cat + art.destroy + assert cat.articles.reload.empty? + end + + should 'show more popular articles' do + art1 = Article.create!(:name => 'article 1', :profile_id => fast_create(Person).id) + art2 = Article.create!(:name => 'article 2', :profile_id => fast_create(Person).id) + art3 = Article.create!(:name => 'article 3', :profile_id => fast_create(Person).id) + + art1.hits = 56; art1.save! + art3.hits = 92; art3.save! + art2.hits = 3; art2.save! + + assert_equal [art3, art1, art2], Article.more_popular + end + + should 'return more commented with pagination' do + art1 = Article.create!(:name => 'article 1', :profile_id => fast_create(Person).id) + art2 = Article.create!(:name => 'article 2', :profile_id => fast_create(Person).id) + art3 = Article.create!(:name => 'article 3', :profile_id => fast_create(Person).id) + + art1.comments_count = 56; art1.save! + art3.comments_count = 92; art3.save! + art2.comments_count = 3; art2.save! + + assert_equal [art3, art1], Article.most_commented(2) + end + + should 'show if article is public' do + art1 = Article.create!(:name => 'article 1', :profile_id => fast_create(Person).id) + art2 = Article.create!(:name => 'article 2', :profile_id => fast_create(Person).id) + art2.advertise = false; art2.save! + art3 = Article.create!(:name => 'article 3', :profile_id => fast_create(Person).id) + art3.published = false; art3.save! + art4 = Article.create!(:name => 'article 4', :profile_id => fast_create(Person).id) + art4.profile.visible = false; art4.save! + art5 = Article.create!(:name => 'article 5', :profile_id => fast_create(Person).id) + art5.profile.public_profile = false; art5.save! + + assert_equal [art1], Article.public + end end diff --git a/test/unit/category_test.rb b/test/unit/category_test.rb index f512ba8..dce6eee 100644 --- a/test/unit/category_test.rb +++ b/test/unit/category_test.rb @@ -32,11 +32,6 @@ class CategoryTest < ActiveSupport::TestCase assert_equal parent_category, c.parent end - # def test_full_text_search - # c = Category.create!(:name => 'product category for testing', :environment_id => @env.id) - # assert @env.product_categories.full_text_search('product*').include?(c) - # end - def test_category_full_name cat = Category.new(:name => 'category_name') assert_equal 'category_name', cat.full_name @@ -102,10 +97,10 @@ class CategoryTest < ActiveSupport::TestCase sub_cat = fast_create(Category, :environment_id => @env.id, :parent_id => cat.id) roots = Category.top_level_for(@env) - + assert_equal 1, roots.size end - + def test_slug c = Category.new(:name => 'Category name') assert_equal 'category-name', c.slug @@ -176,7 +171,7 @@ class CategoryTest < ActiveSupport::TestCase c.display_color = 10 c.valid? assert c.errors.invalid?(:display_color) - + valid = %w[ 1 2 3 4 ].map { |item| item.to_i } valid.each do |item| c.display_color = item @@ -197,7 +192,7 @@ class CategoryTest < ActiveSupport::TestCase c.display_color = 2 c.valid? assert !c.errors.invalid?(:display_color) - + end should 'be able to get top ancestor' do @@ -219,7 +214,7 @@ class CategoryTest < ActiveSupport::TestCase ################################################################ # category filter stuff ################################################################ - + should 'should paginate recent-like methods' do c = @env.categories.build(:name => 'my category'); c.save! assert c.recent_people.respond_to? 'total_entries' @@ -492,30 +487,63 @@ class CategoryTest < ActiveSupport::TestCase assert_not_includes Category.top_level_for(Environment.default).from_types(['ProductCategory']), toplevel_category end + should 'paginate upcoming events' do + category = Category.create!(:name => 'category1', :environment_id => Environment.default.id) + profile = fast_create(Profile) + event1 = category.events.build(:name => 'event1', :start_date => Time.now, :profile => profile) + event2 = category.events.build(:name => 'event2', :start_date => Time.now + 1.hour, :profile => profile) + event3 = category.events.build(:name => 'event3', :start_date => Time.now + 1.day, :profile => profile) + category.save! + assert_equal [event1, event2], category.upcoming_events(2) + end + + should 'remove all article categorizations when destroyed' do + cat = Category.create!(:name => 'category 1', :environment_id => Environment.default.id) + art = Article.create!(:name => 'article 1', :profile_id => fast_create(Person).id) + art.add_category cat + cat.destroy + assert art.categories.reload.empty? + end + + should 'remove all profile categorizations when destroyed' do + cat = Category.create!(:name => 'category 1', :environment_id => Environment.default.id) + p = create(Person, :user_id => fast_create(User).id) + p.add_category cat + cat.destroy + assert p.categories.reload.empty? + end + should 'act as searchable' do - parent = fast_create(Category, :name => 'books') - c = Category.create!(:name => "science fiction", :acronym => "sf", :abbreviation => "sci-fi", - :environment_id => Environment.default.id, :parent_id => parent.id) + parent = fast_create(Category, :name => 'books') + c = Category.create!(:name => "science fiction", :acronym => "sf", :abbreviation => "sci-fi", + :environment_id => Environment.default.id, :parent_id => parent.id) - # fields - assert_includes Category.find_by_contents('fiction')[:results].docs, c - assert_includes Category.find_by_contents('sf')[:results].docs, c - assert_includes Category.find_by_contents('sci-fi')[:results].docs, c - # filters - assert_includes Category.find_by_contents('science', {}, { - :filter_queries => ["parent_id:#{parent.id}"]})[:results].docs, c + # fields + assert_includes Category.find_by_contents('fiction')[:results].docs, c + assert_includes Category.find_by_contents('sf')[:results].docs, c + assert_includes Category.find_by_contents('sci-fi')[:results].docs, c + # filters + assert_includes Category.find_by_contents('science', {}, { + :filter_queries => ["parent_id:#{parent.id}"]})[:results].docs, c end should 'boost name matches' do - c_abbr = Category.create!(:name => "something else", :abbreviation => "science", :environment_id => Environment.default.id) - c_name = Category.create!(:name => "science fiction", :environment_id => Environment.default.id) - assert_equal [c_name, c_abbr], Category.find_by_contents("science")[:results].docs + c_abbr = Category.create!(:name => "something else", :abbreviation => "science", :environment_id => Environment.default.id) + c_name = Category.create!(:name => "science fiction", :environment_id => Environment.default.id) + assert_equal [c_name, c_abbr], Category.find_by_contents("science")[:results].docs end - should 'solr save' do + should 'solr save' do c = @env.categories.build(:name => 'my category'); - c.expects(:solr_save) - c.save! - end + c.expects(:solr_save) + c.save! + end + should 'reindex articles after saving' do + cat = Category.create!(:name => 'category 1', :environment_id => Environment.default.id) + art = Article.create!(:name => 'something', :profile_id => fast_create(Person).id) + Category.expects(:solr_batch_add).with(includes(art)) + art.add_category cat + cat.save! + end end diff --git a/test/unit/certifier_test.rb b/test/unit/certifier_test.rb index 32424b4..3b67adf 100644 --- a/test/unit/certifier_test.rb +++ b/test/unit/certifier_test.rb @@ -58,4 +58,20 @@ class CertifierTest < ActiveSupport::TestCase assert_equal [first, last], Certifier.all.sort end + should 'reindex products after saving' do + product = mock + Certifier.any_instance.stubs(:products).returns([product]) + Certifier.expects(:solr_batch_add).with(includes(product)) + cert = fast_create(Certifier) + cert.save! + end + + should 'set qualifier as self-certified when destroyed' do + pq = mock + Certifier.any_instance.stubs(:product_qualifiers).returns([pq]) + pq.expects(:update_attributes!).with(:certifier => nil) + cert = fast_create(Certifier) + cert.destroy + end + end diff --git a/test/unit/enterprise_test.rb b/test/unit/enterprise_test.rb index 2683c8d..53642a8 100644 --- a/test/unit/enterprise_test.rb +++ b/test/unit/enterprise_test.rb @@ -98,7 +98,7 @@ class EnterpriseTest < ActiveSupport::TestCase assert_not_includes result, ent2 end - should 'be found in search for its product categories hierarchy' do + should 'be found in search for its product categories hierarchy' do ent1 = fast_create(Enterprise, :name => 'test1', :identifier => 'test1') prod_cat = fast_create(ProductCategory, :name => 'pctest', :environment_id => Environment.default.id) prod_child = fast_create(ProductCategory, :name => 'pchild', :environment_id => Environment.default.id, :parent_id => prod_cat.id) @@ -201,9 +201,9 @@ class EnterpriseTest < ActiveSupport::TestCase ent.reload assert_equal 1, ent.boxes.size assert_equal 1, ent.boxes[0].blocks.size - end + end - should 'not replace template if environment doesnt allow' do + should 'not replace template if environment doesnt allow' do inactive_template = fast_create(Enterprise, :name => 'inactive enteprise template', :identifier => 'inactive_enterprise_template') inactive_template.boxes.destroy_all inactive_template.boxes << Box.new @@ -408,8 +408,8 @@ class EnterpriseTest < ActiveSupport::TestCase } Product.create!(:name => "product 4", :enterprise_id => e1.id, :product_category_id => @product_category.id, :highlighted => true) Product.create!(:name => "product 5", :enterprise_id => e1.id, :product_category_id => @product_category.id, :image_builder => { - :uploaded_data => fixture_file_upload('/files/rails.png', 'image/png') - }) + :uploaded_data => fixture_file_upload('/files/rails.png', 'image/png') + }) assert_equal products, e1.highlighted_products_with_image end @@ -421,7 +421,7 @@ class EnterpriseTest < ActiveSupport::TestCase assert_equal product.inputs, enterprise.inputs end - + should 'reindex when products are changed' do enterprise = fast_create(Enterprise) product = fast_create(Product, :enterprise_id => enterprise.id, :product_category_id => @product_category.id) @@ -458,4 +458,14 @@ class EnterpriseTest < ActiveSupport::TestCase e = fast_create(Enterprise) assert_respond_to e, :production_costs end + + should 'reindex products with full category name after save' do + product = mock + product.expects(:category_full_name) + Enterprise.any_instance.stubs(:products).returns([product]) + Enterprise.expects(:solr_batch_add).with(includes(product)) + ent = fast_create(Enterprise) + ent.save! + end + end diff --git a/test/unit/location_block_test.rb b/test/unit/location_block_test.rb index e556671..d66699f 100644 --- a/test/unit/location_block_test.rb +++ b/test/unit/location_block_test.rb @@ -21,9 +21,15 @@ class LocationBlockTest < ActiveSupport::TestCase should 'be editable' do assert LocationBlock.new.editable? end - + should 'default title be blank by default' do assert_equal '', LocationBlock.new.title end + should 'use google maps api v3' do + @block.owner.lat = '-12.34'; @block.owner.save! + assert_match 'http://maps.google.com/maps/api/staticmap', @block.content + assert_no_match /key=/, @block.content + end + end diff --git a/test/unit/product_category_test.rb b/test/unit/product_category_test.rb index 2e7f2b1..108a364 100644 --- a/test/unit/product_category_test.rb +++ b/test/unit/product_category_test.rb @@ -15,7 +15,7 @@ class ProductCategoryTest < ActiveSupport::TestCase p1 = Product.create(:name => 'product2', :product_category => c1, :enterprise_id => profile.id) c0.reload; c1.reload assert_equivalent [p0, p1], c0.all_products - assert_equivalent [p1], c1.all_products + assert_equivalent [p1], c1.all_products end should 'return top level product categories for environment when no parent product category specified' do @@ -35,4 +35,13 @@ class ProductCategoryTest < ActiveSupport::TestCase assert_equal [c11], ProductCategory.menu_categories(c1, nil) end + + should 'reindex products after save' do + product = mock + ProductCategory.any_instance.stubs(:products).returns([product]) + ProductCategory.expects(:solr_batch_add).with(includes(product)) + pc = fast_create(ProductCategory) + pc.save! + end + end diff --git a/test/unit/product_test.rb b/test/unit/product_test.rb index 267d5e1..a7d30fa 100644 --- a/test/unit/product_test.rb +++ b/test/unit/product_test.rb @@ -8,6 +8,13 @@ class ProductTest < ActiveSupport::TestCase @profile = fast_create(Enterprise) end + should 'validate the presence of enterprise' do + p = Product.new + assert_raise ActiveRecord::RecordInvalid do + p.save! + end + end + should 'return associated enterprise region' do @profile.region = fast_create Region, :name => 'Salvador' @profile.save! @@ -82,7 +89,7 @@ class ProductTest < ActiveSupport::TestCase end end - should 'calculate catagory full name' do + should 'calculate category full name' do cat = mock cat.expects(:full_name).returns('A/B/C') @@ -221,20 +228,27 @@ class ProductTest < ActiveSupport::TestCase end should 'format values to float with 2 decimals' do - ent = fast_create(Enterprise, :name => 'test ent 1', :identifier => 'test_ent1') - product = fast_create(Product, :enterprise_id => ent.id, :price => 12.994, :discount => 1.994) + ent = fast_create(Enterprise, :name => 'test ent 1', :identifier => 'test_ent1') + product = fast_create(Product, :enterprise_id => ent.id, :price => 12.994, :discount => 1.994) assert_equal "12.99", product.formatted_value(:price) assert_equal "1.99", product.formatted_value(:discount) end should 'calculate price with discount' do - ent = fast_create(Enterprise, :name => 'test ent 1', :identifier => 'test_ent1') - product = fast_create(Product, :enterprise_id => ent.id, :price => 12.994, :discount => 1.994) + ent = fast_create(Enterprise, :name => 'test ent 1', :identifier => 'test_ent1') + product = fast_create(Product, :enterprise_id => ent.id, :price => 12.994, :discount => 1.994) assert_equal 11.00, product.price_with_discount end + should 'calculate price without discount' do + ent = fast_create(Enterprise, :name => 'test ent 1', :identifier => 'test_ent1') + product = fast_create(Product, :enterprise_id => ent.id, :price => 12.994, :discount => 0) + + assert_equal product.price, product.price_with_discount + end + should 'have default image' do product = Product.new assert_equal '/images/icons-app/product-default-pic-thumb.png', product.default_image @@ -251,24 +265,24 @@ class ProductTest < ActiveSupport::TestCase end should 'return product inputs' do - ent = fast_create(Enterprise) - product = fast_create(Product, :enterprise_id => ent.id) - input = fast_create(Input, :product_id => product.id, :product_category_id => @product_category.id) + ent = fast_create(Enterprise) + product = fast_create(Product, :enterprise_id => ent.id) + input = fast_create(Input, :product_id => product.id, :product_category_id => @product_category.id) - assert_equal [input], product.inputs + assert_equal [input], product.inputs end should 'destroy inputs when product is removed' do - ent = fast_create(Enterprise) - product = fast_create(Product, :enterprise_id => ent.id) - input = fast_create(Input, :product_id => product.id, :product_category_id => @product_category.id) + ent = fast_create(Enterprise) + product = fast_create(Product, :enterprise_id => ent.id) + input = fast_create(Input, :product_id => product.id, :product_category_id => @product_category.id) - services_category = fast_create(ProductCategory, :name => 'Services') - input2 = fast_create(Input, :product_id => product.id, :product_category_id => services_category.id) + services_category = fast_create(ProductCategory, :name => 'Services') + input2 = fast_create(Input, :product_id => product.id, :product_category_id => services_category.id) - assert_difference Input, :count, -2 do - product.destroy - end + assert_difference Input, :count, -2 do + product.destroy + end end should 'test if name is blank' do @@ -501,71 +515,242 @@ class ProductTest < ActiveSupport::TestCase assert_equal 0, product.price_description_percentage end + should 'return solidarity percentage from inputs' do + prod = fast_create(Product, :name => 'test product1', :product_category_id => @product_category.id, :enterprise_id => @profile.id) + puts "$$$$ #{prod.percentage_from_solidarity_economy}" + assert_equal 0, prod.percentage_from_solidarity_economy.first + + Input.create!(:product_id => prod.id, :product_category_id => @product_category.id, + :amount_used => 10, :price_per_unit => 10, :is_from_solidarity_economy => false) + assert_equal 0, prod.percentage_from_solidarity_economy.first + + Input.create!(:product_id => prod.id, :product_category_id => @product_category.id, + :amount_used => 10, :price_per_unit => 10, :is_from_solidarity_economy => true) + assert_equal 50, prod.percentage_from_solidarity_economy.first + + Input.create!(:product_id => prod.id, :product_category_id => @product_category.id, + :amount_used => 10, :price_per_unit => 10, :is_from_solidarity_economy => false) + assert_equal 25, prod.percentage_from_solidarity_economy.first + + prod = fast_create(Product, :name => 'test product1', :product_category_id => @product_category.id, :enterprise_id => @profile.id) + Input.create!(:product_id => prod.id, :product_category_id => @product_category.id, + :amount_used => 10, :price_per_unit => 10, :is_from_solidarity_economy => true) + Input.create!(:product_id => prod.id, :product_category_id => @product_category.id, + :amount_used => 10, :price_per_unit => 10, :is_from_solidarity_economy => true) + Input.create!(:product_id => prod.id, :product_category_id => @product_category.id, + :amount_used => 10, :price_per_unit => 10, :is_from_solidarity_economy => true) + Input.create!(:product_id => prod.id, :product_category_id => @product_category.id, + :amount_used => 10, :price_per_unit => 10, :is_from_solidarity_economy => false) + assert_equal 75, prod.percentage_from_solidarity_economy.first + + prod = fast_create(Product, :name => 'test product', :product_category_id => @product_category.id, :enterprise_id => @profile.id) + Input.create!(:product_id => prod.id, :product_category_id => @product_category.id, + :amount_used => 10, :price_per_unit => 10, :is_from_solidarity_economy => true) + assert_equal 100, prod.percentage_from_solidarity_economy.first + end + + should 'delegate region info to enterprise' do + enterprise = fast_create(Enterprise) + Enterprise.any_instance.expects(:region) + Enterprise.any_instance.expects(:region_id) + product = fast_create(Product, :enterprise_id => enterprise.id) + product.region + product.region_id + end + + should 'delegate environment info to enterprise' do + enterprise = fast_create(Enterprise) + Enterprise.any_instance.expects(:environment) + Enterprise.any_instance.expects(:environment_id) + product = fast_create(Product, :enterprise_id => enterprise.id) + product.environment + product.environment_id + end + should 'act as faceted' do - s = fast_create(State, :acronym => 'XZ') - c = fast_create(City, :name => 'Tabajara', :parent_id => s.id) - ent = fast_create(Enterprise, :region_id => c.id) - p = fast_create(Product, :enterprise_id => ent.id) + s = fast_create(State, :acronym => 'XZ') + c = fast_create(City, :name => 'Tabajara', :parent_id => s.id) + ent = fast_create(Enterprise, :region_id => c.id) + cat = fast_create(ProductCategory, :name => 'hardcore') + p = Product.create!(:name => 'black flag', :enterprise_id => ent.id, :product_category_id => cat.id) pq = p.product_qualifiers.create!(:qualifier => fast_create(Qualifier, :name => 'qualifier'), - :certifier => fast_create(Certifier, :name => 'certifier')) - assert_equal 'Related products', Product.facet_by_id(:f_category)[:label] - assert_equal ['Tabajara', ', XZ'], Product.facet_by_id(:f_region)[:proc].call(p.send(:f_region)) - assert_equal ['qualifier', ' cert. certifier'], Product.facet_by_id(:f_qualifier)[:proc].call(p.send(:f_qualifier).last) + :certifier => fast_create(Certifier, :name => 'certifier')) + assert_equal 'Related products', Product.facet_by_id(:f_category)[:label] + assert_equal ['Tabajara', ', XZ'], Product.facet_by_id(:f_region)[:proc].call(p.send(:f_region)) + assert_equal ['qualifier', ' cert. certifier'], Product.facet_by_id(:f_qualifier)[:proc].call(p.send(:f_qualifier).last) + assert_equal 'hardcore', p.send(:f_category) + assert_equal "category_filter:#{cat.id}", Product.facet_category_query.call(cat) end should 'act as searchable' do - s = fast_create(State, :acronym => 'XZ') - c = fast_create(City, :name => 'Tabajara', :parent_id => s.id) - ent = fast_create(Enterprise, :region_id => c.id, :name => "Black Sun") - category = fast_create(ProductCategory, :name => "homemade", :acronym => "hm", :abbreviation => "homey") - p = Product.create!(:name => 'bananas syrup', :description => 'surrounded by mosquitos', :enterprise_id => ent.id, - :product_category_id => category.id) - qual = Qualifier.create!(:name => 'qualificador', :environment_id => Environment.default.id) - cert = Certifier.create!(:name => 'certificador', :environment_id => Environment.default.id) + s = fast_create(State, :acronym => 'XZ') + c = fast_create(City, :name => 'Tabajara', :parent_id => s.id) + ent = fast_create(Enterprise, :region_id => c.id, :name => "Black Sun") + category = fast_create(ProductCategory, :name => "homemade", :acronym => "hm", :abbreviation => "homey") + p = Product.create!(:name => 'bananas syrup', :description => 'surrounded by mosquitos', :enterprise_id => ent.id, + :product_category_id => category.id) + qual = Qualifier.create!(:name => 'qualificador', :environment_id => Environment.default.id) + cert = Certifier.create!(:name => 'certificador', :environment_id => Environment.default.id) pq = p.product_qualifiers.create!(:qualifier => qual, :certifier => cert) - # fields - assert_includes Product.find_by_contents('bananas')[:results].docs, p - assert_includes Product.find_by_contents('mosquitos')[:results].docs, p - assert_includes Product.find_by_contents('homemade')[:results].docs, p - # filters - assert_includes Product.find_by_contents('bananas', {}, { - :filter_queries => ["public:true"]})[:results].docs, p - assert_not_includes Product.find_by_contents('bananas', {}, { - :filter_queries => ["public:false"]})[:results].docs, p - assert_includes Product.find_by_contents('bananas', {}, { - :filter_queries => ["environment_id:\"#{Environment.default.id}\""]})[:results].docs, p + p.qualifiers.reload + p.certifiers.reload + p.save! + # fields + assert_includes Product.find_by_contents('bananas')[:results].docs, p + assert_includes Product.find_by_contents('mosquitos')[:results].docs, p + assert_includes Product.find_by_contents('homemade')[:results].docs, p + # filters + assert_includes Product.find_by_contents('bananas', {}, { :filter_queries => ["public:true"]})[:results].docs, p + assert_not_includes Product.find_by_contents('bananas', {}, { :filter_queries => ["public:false"]})[:results].docs, p + assert_includes Product.find_by_contents('bananas', {}, { :filter_queries => ["environment_id:\"#{Environment.default.id}\""]})[:results].docs, p # includes - assert_includes Product.find_by_contents("homemade")[:results].docs, p - assert_includes Product.find_by_contents(category.slug)[:results].docs, p - assert_includes Product.find_by_contents("hm")[:results].docs, p - assert_includes Product.find_by_contents("homey")[:results].docs, p - assert_includes Product.find_by_contents("Tabajara")[:results].docs, p - assert_includes Product.find_by_contents("Black Sun")[:results].docs, p + assert_includes Product.find_by_contents("homemade")[:results].docs, p + assert_includes Product.find_by_contents(category.slug)[:results].docs, p + assert_includes Product.find_by_contents("hm")[:results].docs, p + assert_includes Product.find_by_contents("homey")[:results].docs, p + assert_includes Product.find_by_contents("Tabajara")[:results].docs, p + assert_includes Product.find_by_contents("Black Sun")[:results].docs, p + assert_includes Product.find_by_contents("qualificador")[:results].docs, p + assert_includes Product.find_by_contents("certificador")[:results].docs, p end should 'boost name matches' do - ent = fast_create(Enterprise) - cat = fast_create(ProductCategory) - in_desc = Product.create!(:name => 'something', :enterprise_id => ent.id, :description => 'bananas in the description!', - :product_category_id => cat.id) - in_name = Product.create!(:name => 'bananas in the name!', :enterprise_id => ent.id, :product_category_id => cat.id) - assert_equal [in_name, in_desc], Product.find_by_contents('bananas')[:results].docs - end - - should 'boost if profile is enabled' do - person2 = fast_create(Person, :enabled => false) - art_profile_disabled = Article.create!(:name => 'profile disabled', :profile_id => person2.id) - person1 = fast_create(Person, :enabled => true) - art_profile_enabled = Article.create!(:name => 'profile enabled', :profile_id => person1.id) - assert_equal [art_profile_enabled, art_profile_disabled], Article.find_by_contents('profile')[:results].docs - end - - should 'reindex enterprise after saving' do - ent = fast_create(Enterprise) - cat = fast_create(ProductCategory) - prod = Product.create!(:name => 'something', :enterprise_id => ent.id, :product_category_id => cat.id) - Product.expects(:solr_batch_add).with([ent]) - prod.save! - end + ent = fast_create(Enterprise) + cat = fast_create(ProductCategory) + in_desc = Product.create!(:name => 'something', :enterprise_id => ent.id, :description => 'bananas in the description!', + :product_category_id => cat.id) + in_name = Product.create!(:name => 'bananas in the name!', :enterprise_id => ent.id, :product_category_id => cat.id) + assert_equal [in_name, in_desc], Product.find_by_contents('bananas')[:results].docs + end + + should 'reindex enterprise after saving' do + ent = fast_create(Enterprise) + cat = fast_create(ProductCategory) + prod = Product.create!(:name => 'something', :enterprise_id => ent.id, :product_category_id => cat.id) + Product.expects(:solr_batch_add).with([ent]) + prod.save! + end + + should 'boost search results that include an image' do + product_without_image = Product.create!(:name => 'product without image', :product_category => @product_category, + :enterprise_id => @profile.id) + product_with_image = Product.create!(:name => 'product with image', :product_category => @product_category, + :image_builder => { :uploaded_data => fixture_file_upload('/files/rails.png', 'image/png')}, + :enterprise_id => @profile.id) + assert_equal [product_with_image, product_without_image], Product.find_by_contents('product image')[:results].docs + end + + should 'boost search results that include qualifier' do + product_without_q = Product.create!(:name => 'product without qualifier', :product_category => @product_category, + :enterprise_id => @profile.id) + product_with_q = Product.create!(:name => 'product with qualifier', :product_category => @product_category, + :enterprise_id => @profile.id) + product_with_q.product_qualifiers.create(:qualifier => fast_create(Qualifier), :certifier => nil) + product_with_q.save! + + assert_equal [product_with_q, product_without_q], Product.find_by_contents('product qualifier')[:results].docs + end + + should 'boost search results with open price' do + product = Product.create!(:name => 'product 1', :product_category => @product_category, :enterprise_id => @profile.id) + product.price = 100 + product.save! + open_price = Product.create!(:name => 'product 2', :product_category => @product_category, :enterprise_id => @profile.id) + open_price.price = 100 + Input.create!(:product_id => open_price.id, :product_category_id => @product_category.id, + :amount_used => 10, :price_per_unit => 10) + open_price.update_price_details [] + open_price.save! + + #pp Product::Boosts[2][2].call(product) + #pp Product::Boosts[2][2].call(open_price) + #pp Product.find_by_contents('product')[:results].docs.first.solr_score + #pp Product.find_by_contents('product')[:results].docs.last.solr_score + assert_equal [open_price, product], Product.find_by_contents('product')[:results].docs + end + + should 'boost search results with solidarity inputs' do + product = Product.create!(:name => 'product 1', :product_category => @product_category, :enterprise_id => @profile.id) + perc_50 = Product.create!(:name => 'product 2', :product_category => @product_category, :enterprise_id => @profile.id) + Input.create!(:product_id => perc_50.id, :product_category_id => @product_category.id, + :amount_used => 10, :price_per_unit => 10, :is_from_solidarity_economy => true) + Input.create!(:product_id => perc_50.id, :product_category_id => @product_category.id, + :amount_used => 10, :price_per_unit => 10, :is_from_solidarity_economy => false) + perc_50.save! + perc_75 = Product.create!(:name => 'product 3', :product_category => @product_category, :enterprise_id => @profile.id) + Input.create!(:product_id => perc_75.id, :product_category_id => @product_category.id, + :amount_used => 10, :price_per_unit => 10, :is_from_solidarity_economy => false) + Input.create!(:product_id => perc_75.id, :product_category_id => @product_category.id, + :amount_used => 10, :price_per_unit => 10, :is_from_solidarity_economy => true) + Input.create!(:product_id => perc_75.id, :product_category_id => @product_category.id, + :amount_used => 10, :price_per_unit => 10, :is_from_solidarity_economy => true) + Input.create!(:product_id => perc_75.id, :product_category_id => @product_category.id, + :amount_used => 10, :price_per_unit => 10, :is_from_solidarity_economy => true) + perc_75.save! + + assert_equal [perc_75, perc_50, product], Product.find_by_contents('product')[:results].docs + end + + should 'boost available search results' do + product = Product.create!(:name => 'product 1', :product_category => @product_category, :enterprise_id => @profile.id) + product.available = false + product.save! + product2 = Product.create!(:name => 'product 2', :product_category => @product_category, :enterprise_id => @profile.id) + product2.available = true + product2.save! + + assert_equal [product2, product], Product.find_by_contents('product')[:results].docs + end + + should 'boost search results created updated recently' do + product = Product.create!(:name => 'product 1', :product_category => @product_category, :enterprise_id => @profile.id) + product.update_attribute :created_at, Time.now - 10.day + product2 = Product.create!(:name => 'product 2', :product_category => @product_category, :enterprise_id => @profile.id) + + assert_equal [product2, product], Product.find_by_contents('product')[:results].docs + end + + should 'boost search results with description' do + product = Product.create!(:name => 'product 1', :product_category => @product_category, :enterprise_id => @profile.id, + :description => '') + product2 = Product.create!(:name => 'product 2', :product_category => @product_category, :enterprise_id => @profile.id, + :description => 'a small description') + + assert_equal [product2, product], Product.find_by_contents('product')[:results].docs + end + + should 'boost if enterprise is enabled' do + ent = Enterprise.create!(:name => 'ent', :identifier => 'ent', :enabled => false) + product = Product.create!(:name => 'product 1', :product_category => @product_category, :enterprise_id => ent.id) + product2 = Product.create!(:name => 'product 2', :product_category => @product_category, :enterprise_id => @profile.id) + + assert_equal [product2, product], Product.find_by_contents('product')[:results].docs + end + + should 'combine different boost types' do + product = Product.create!(:name => 'product', :product_category => @product_category, :enterprise_id => @profile.id) + image_only = Product.create!(:name => 'product with image', :product_category => @product_category, + :image_builder => { :uploaded_data => fixture_file_upload('/files/rails.png', 'image/png')}, + :enterprise_id => @profile.id) + qual_only = Product.create!(:name => 'product with qualifier', :product_category => @product_category, + :enterprise_id => @profile.id) + img_and_qual = Product.create!(:name => 'product with image and qualifier', :product_category => @product_category, + :image_builder => { :uploaded_data => fixture_file_upload('/files/rails.png', 'image/png')}, + :enterprise_id => @profile.id) + qual_only.product_qualifiers.create(:qualifier => fast_create(Qualifier), :certifier => nil) + img_and_qual.product_qualifiers.create(:qualifier => fast_create(Qualifier), :certifier => nil) + qual_only.save! + img_and_qual.save! + + assert_equal [img_and_qual, image_only, qual_only, product], Product.find_by_contents('product')[:results].docs + end + + should 'return more recent products' do + prod1 = Product.create!(:name => 'Damaged LP', :enterprise_id => @profile.id, :product_category_id => @product_category.id) + prod2 = Product.create!(:name => 'Damaged CD', :enterprise_id => @profile.id, :product_category_id => @product_category.id) + prod3 = Product.create!(:name => 'Damaged DVD', :enterprise_id => @profile.id, :product_category_id => @product_category.id) + + assert_equal [prod3, prod2, prod1], Product.more_recent + end end diff --git a/test/unit/profile_test.rb b/test/unit/profile_test.rb index 8cbe525..340f854 100644 --- a/test/unit/profile_test.rb +++ b/test/unit/profile_test.rb @@ -192,7 +192,7 @@ class ProfileTest < ActiveSupport::TestCase assert_not_equal list.object_id, other_list.object_id end -# This problem should be solved; talk to Bráulio if it fails + # This problem should be solved; talk to Bráulio if it fails should 'be able to find profiles by their names' do small = create(Profile, :name => 'A small profile for testing') big = create(Profile, :name => 'A big profile for testing') @@ -388,12 +388,19 @@ class ProfileTest < ActiveSupport::TestCase assert_respond_to c, :categories end + should 'responds to categories including virtual' do + c = fast_create(Profile) + assert_respond_to c, :categories_including_virtual + end + should 'have categories' do c = fast_create(Profile) - cat = Environment.default.categories.build(:name => 'a category'); cat.save! + pcat = Environment.default.categories.build(:name => 'a category'); pcat.save! + cat = Environment.default.categories.build(:name => 'a category', :parent_id => pcat.id); cat.save! c.add_category cat c.save! assert_includes c.categories, cat + assert_includes c.categories_including_virtual, pcat end should 'be able to list recent profiles' do @@ -543,13 +550,15 @@ class ProfileTest < ActiveSupport::TestCase profile = create_user('testuser').person profile.add_category(c3) - assert_equal [c3], profile.categories(true) assert_equal [profile], c2.people(true) assert_includes c3.people(true), profile assert_includes c2.people(true), profile assert_includes c1.people(true), profile + + assert_includes profile.categories_including_virtual, c2 + assert_includes profile.categories_including_virtual, c1 end should 'redefine the entire category set at once' do @@ -564,15 +573,18 @@ class ProfileTest < ActiveSupport::TestCase profile.category_ids = [c2,c3].map(&:id) assert_equivalent [c2, c3], profile.categories(true) + assert_equivalent [c2, c1, c3], profile.categories_including_virtual(true) end should 'be able to create a profile with categories' do - c1 = create(Category) + pcat = create(Category) + c1 = create(Category, :parent_id => pcat) c2 = create(Category) profile = create(Profile, :category_ids => [c1.id, c2.id]) assert_equivalent [c1, c2], profile.categories(true) + assert_equivalent [c1, pcat, c2], profile.categories_including_virtual(true) end should 'be associated with a region' do @@ -625,32 +637,38 @@ class ProfileTest < ActiveSupport::TestCase should 'be able to create with categories and region at the same time' do region = fast_create(Region) - category = fast_create(Category) + pcat = fast_create(Category) + category = fast_create(Category, :parent_id => pcat.id) profile = create(Profile, :region => region, :category_ids => [category.id]) assert_equivalent [region, category], profile.categories(true) + assert_equivalent [region, category, pcat], profile.categories_including_virtual(true) end should 'be able to update categories and not get regions removed' do region = fast_create(Region) category = fast_create(Category) - category2 = fast_create(Category) + pcat = fast_create(Category) + category2 = fast_create(Category, :parent_id => pcat.id) profile = create(Profile, :region => region, :category_ids => [category.id]) profile.update_attributes!(:category_ids => [category2.id]) assert_includes profile.categories(true), region + assert_includes profile.categories_including_virtual(true), pcat end should 'be able to update region and not get categories removed' do region = fast_create(Region) region2 = fast_create(Region) - category = fast_create(Category) + pcat = fast_create(Category) + category = fast_create(Category, :parent_id => pcat.id) profile = create(Profile, :region => region, :category_ids => [category.id]) profile.update_attributes!(:region => region2) assert_includes profile.categories(true), category + assert_includes profile.categories_including_virtual(true), pcat end should 'not accept product category as category' do @@ -757,6 +775,7 @@ class ProfileTest < ActiveSupport::TestCase profile = fast_create(Profile) profile.category_ids = [c2,c3,c3].map(&:id) assert_equal [c2, c3], profile.categories(true) + assert_equal [c2, c1, c3], profile.categories_including_virtual(true) end should 'not return nil members when a member is removed from system' do @@ -965,7 +984,7 @@ class ProfileTest < ActiveSupport::TestCase assert !a_copy.advertise end - + should 'copy set of boxes from profile template' do template = fast_create(Profile) template.boxes.destroy_all @@ -1403,10 +1422,12 @@ class ProfileTest < ActiveSupport::TestCase should 'ignore category with id zero' do profile = fast_create(Profile) - c = fast_create(Category) + pcat = fast_create(Category, :id => 0) + c = fast_create(Category, :parent_id => pcat.id) profile.category_ids = ['0', c.id, nil] assert_equal [c], profile.categories + assert_not_includes profile.categories_including_virtual, [pcat] end should 'get first blog when has multiple blogs' do @@ -1772,48 +1793,51 @@ class ProfileTest < ActiveSupport::TestCase end should 'act as faceted' do - st = fast_create(State, :acronym => 'XZ') - city = fast_create(City, :name => 'Tabajara', :parent_id => st.id) + st = fast_create(State, :acronym => 'XZ') + city = fast_create(City, :name => 'Tabajara', :parent_id => st.id) + cat = fast_create(Category) prof = fast_create(Person, :region_id => city.id) - assert_equal ['Tabajara', ', XZ'], Profile.facet_by_id(:f_region)[:proc].call(prof.send(:f_region)) + prof.add_category(cat, true) + assert_equal ['Tabajara', ', XZ'], Profile.facet_by_id(:f_region)[:proc].call(prof.send(:f_region)) + assert_equal "category_filter:#{cat.id}", Person.facet_category_query.call(cat) end should 'act as searchable' do - st = fast_create(State, :acronym => 'CA') - city = fast_create(City, :name => 'Inglewood', :parent_id => st.id) + st = create(State, :name => 'California', :acronym => 'CA', :environment_id => Environment.default.id) + city = create(City, :name => 'Inglewood', :parent_id => st.id, :environment_id => Environment.default.id) p = create(Person, :name => "Hiro", :address => 'U-Stor-It', :nickname => 'Protagonist', - :user_id => fast_create(User).id, :region_id => city.id) - cat = fast_create(Category, :name => "Science Fiction", :acronym => "sf", :abbreviation => "sci-fi") - p.add_category cat - cat.save! - p.save! - - # fields - assert_includes Profile.find_by_contents('Hiro')[:results].docs, p - assert_includes Profile.find_by_contents('Stor')[:results].docs, p - assert_includes Profile.find_by_contents('Protagonist')[:results].docs, p - # filters - assert_includes Profile.find_by_contents('Hiro', {}, { - :filter_queries => ["public:true"]})[:results].docs, p - assert_not_includes Profile.find_by_contents('Hiro', {}, { - :filter_queries => ["public:false"]})[:results].docs, p - assert_includes Profile.find_by_contents('Hiro', {}, { - :filter_queries => ["environment_id:\"#{Environment.default.id}\""]})[:results].docs, p + :user_id => fast_create(User).id, :region_id => city.id) + cat = create(Category, :name => "Science Fiction", :acronym => "sf", :abbreviation => "sci-fi") + p.add_category cat + cat.profiles.reload + cat.save! + p.save! + + # fields + assert_includes Profile.find_by_contents('Hiro')[:results].docs, p + assert_includes Profile.find_by_contents('Stor')[:results].docs, p + assert_includes Profile.find_by_contents('Protagonist')[:results].docs, p + # filters + assert_includes Profile.find_by_contents('Hiro', {}, { :filter_queries => ["public:true"]})[:results].docs, p + assert_not_includes Profile.find_by_contents('Hiro', {}, { :filter_queries => ["public:false"]})[:results].docs, p + assert_includes Profile.find_by_contents('Hiro', {}, { :filter_queries => ["environment_id:\"#{Environment.default.id}\""]})[:results].docs, p # includes - assert_includes Profile.find_by_contents("Inglewood")[:results].docs, p + assert_includes Profile.find_by_contents("Inglewood")[:results].docs, p + assert_includes Profile.find_by_contents("California")[:results].docs, p + assert_includes Profile.find_by_contents("Science")[:results].docs, p end should 'boost name matches' do - in_addr = create(Person, :name => 'something', :address => 'bananas in the address!', :user_id => fast_create(User).id) + in_addr = create(Person, :name => 'something', :address => 'bananas in the address!', :user_id => fast_create(User).id) in_name = create(Person, :name => 'bananas in the name!', :user_id => fast_create(User).id) - assert_equal [in_name, in_addr], Person.find_by_contents('bananas')[:results].docs + assert_equal [in_name, in_addr], Person.find_by_contents('bananas')[:results].docs end - should 'reindex articles after saving' do - profile = create(Person, :name => 'something', :user_id => fast_create(User).id) - art = profile.articles.build(:name => 'something') - Profile.expects(:solr_batch_add).with(includes(art)) - profile.save! - end + should 'reindex articles after saving' do + profile = create(Person, :name => 'something', :user_id => fast_create(User).id) + art = profile.articles.build(:name => 'something') + Profile.expects(:solr_batch_add).with(includes(art)) + profile.save! + end end diff --git a/test/unit/qualifier_test.rb b/test/unit/qualifier_test.rb index 0c6fe5d..213c576 100644 --- a/test/unit/qualifier_test.rb +++ b/test/unit/qualifier_test.rb @@ -61,4 +61,11 @@ class QualifierTest < ActiveSupport::TestCase assert_equal [], product1.product_qualifiers(true) end + should 'reindex products after saving' do + product = mock + Qualifier.any_instance.stubs(:products).returns([product]) + Qualifier.expects(:solr_batch_add).with(includes(product)) + qual = fast_create(Qualifier) + qual.save! + end end diff --git a/test/unit/set_profile_region_from_city_state_test.rb b/test/unit/set_profile_region_from_city_state_test.rb index e69de29..87f46c0 100644 --- a/test/unit/set_profile_region_from_city_state_test.rb +++ b/test/unit/set_profile_region_from_city_state_test.rb @@ -0,0 +1,33 @@ +require File.dirname(__FILE__) + '/../test_helper' + +class SetProfileRegionFromCityStateTest < ActiveSupport::TestCase + + should 'set city and state from names' do + s = State.create!(:name => 'Sao Paulo', :acronym => 'SP', :environment_id => Environment.default.id) + c = City.create!(:name => 'Pindamonhangaba', :parent_id => s.id, :environment_id => Environment.default.id) + p = fast_create(Person, :user_id => fast_create(User).id) + p.state_with_region = 'SP' + p.city_with_region = 'Pindamonhangaba' + p.save! + assert p.region == c + end + + should 'set region to null if city not found' do + s = State.create!(:name => 'Sao Paulo', :acronym => 'SP', :environment_id => Environment.default.id) + p = fast_create(Person, :user_id => fast_create(User).id) + p.state_with_region = 'SP' + p.city_with_region = 'Pindamonhangaba' + p.save! + assert p.region.nil? + end + + should 'set region to null if state not found' do + s = State.create!(:name => 'Sao Paulo', :acronym => 'SP', :environment_id => Environment.default.id) + c = City.create!(:name => 'Pindamonhangaba', :parent_id => s.id, :environment_id => Environment.default.id) + p = fast_create(Person, :user_id => fast_create(User).id) + p.state_with_region = 'RJ' + p.city_with_region = 'Pindamonhangaba' + p.save! + assert p.region.nil? + end +end -- libgit2 0.21.2