recommendable 2.1.0.2 → 2.1.1

data/test/dummy/script/rails

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# This command will automatically be run when you run "rails" with Rails 3 gems installed from the root of your application.
+
+APP_PATH = File.expand_path('../../config/application',  __FILE__)
+require File.expand_path('../../config/boot',  __FILE__)
+require 'rails/commands'

data/test/factories.rb

@@ -0,0 +1,17 @@
+Factory.define(:user) do |f|
+  f.email 'user%d@example.com'
+end
+
+Factory.define(:movie) do |f|
+  f.title '%{year}: A Space Odyssey'
+  f.year  { '200%d'.to_i }
+end
+
+Factory.define(:book) do |f|
+  f.title  'Harry Potter Vol. %d'
+  f.author 'J.K. Rowling'
+end
+
+Factory.define(:rock) do |f|
+  f.name 'Boring Specimen No. %d'
+end

data/test/recommendable/helpers/calculations_test.rb

@@ -0,0 +1,69 @@
+$LOAD_PATH.unshift File.expand_path('../../test', __FILE__)
+require 'test_helper'
+
+class CalculationsTest < MiniTest::Unit::TestCase
+  def setup
+    @user = Factory(:user)
+    5.times  { |x| instance_variable_set(:"@user#{x+1}",  Factory(:user))  }
+    10.times { |x| instance_variable_set(:"@movie#{x+1}", Factory(:movie)) }
+    10.times { |x| instance_variable_set(:"@book#{x+1}",  Factory(:book))  }
+
+    [@movie1, @movie2, @movie3, @book4, @book5, @book6].each { |obj| @user.like(obj) }
+    [@book1, @book2, @book3, @movie4, @movie5, @movie6].each { |obj| @user.dislike(obj) }
+
+    # @user.similarity_with(@user1) should ==  1.0
+    [@movie1, @movie2, @movie3, @book4, @book5, @book6, @book7, @book8, @movie9, @movie10].each { |obj| @user1.like(obj) }
+    [@book1, @book2, @book3, @movie4, @movie5, @movie6, @movie7, @movie8, @book9, @book10].each { |obj| @user1.dislike(obj) }
+
+    # @user.similarity_with(@user2) should ==  0.25
+    [@movie1, @movie2, @movie3, @book4, @book5, @book6].each { |obj| @user2.like(obj) }
+    [@book1, @book2, @book3].each { |obj| @user2.like(obj) }
+
+    # @user.similarity_with(@user3) should ==  0.0
+    [@movie1, @movie2, @movie3].each { |obj| @user3.like(obj) }
+    [@book1, @book2, @book3].each { |obj| @user3.like(obj) }
+
+    # @user.similarity_with(@user4) should == -0.25
+    [@movie1, @movie2, @movie3].each { |obj| @user4.like(obj) }
+    [@book1, @book2, @book3, @movie4, @movie5, @movie6].each { |obj| @user4.like(obj) }
+
+    # @user.similarity_with(@user5) should == -1.0
+    [@movie1, @movie2, @movie3, @book4, @book5, @book6].each { |obj| @user5.dislike(obj) }
+    [@book1, @book2, @book3, @movie4, @movie5, @movie6].each { |obj| @user5.like(obj) }
+  end
+
+  def test_similarity_between_calculates_correctly
+    assert_equal Recommendable::Helpers::Calculations.similarity_between(@user.id, @user1.id), 1.0
+    assert_equal Recommendable::Helpers::Calculations.similarity_between(@user.id, @user2.id), 0.25
+    assert_equal Recommendable::Helpers::Calculations.similarity_between(@user.id, @user3.id), 0
+    assert_equal Recommendable::Helpers::Calculations.similarity_between(@user.id, @user4.id), -0.25
+    assert_equal Recommendable::Helpers::Calculations.similarity_between(@user.id, @user5.id), -1.0
+  end
+
+  def test_update_recommendations_ignores_rated_items
+    Recommendable::Helpers::Calculations.update_similarities_for(@user.id)
+    Recommendable::Helpers::Calculations.update_recommendations_for(@user.id)
+
+    movies = @user.liked_movies + @user.disliked_movies
+    books  = @user.liked_books  + @user.disliked_books
+
+    movies.each { |m| refute_includes @user.recommended_movies, m }
+    books.each  { |b| refute_includes @user.recommended_books,  b }
+  end
+
+  def test_predict_for_returns_predictions
+    Recommendable::Helpers::Calculations.update_similarities_for(@user.id)
+    assert_equal Recommendable::Helpers::Calculations.predict_for(@user.id, @book7.class, @book7.id), 1.0
+    assert_equal Recommendable::Helpers::Calculations.predict_for(@user.id, @book8.class, @book8.id), 1.0
+    assert_equal Recommendable::Helpers::Calculations.predict_for(@user.id, @book9.class, @book9.id), -1.0
+    assert_equal Recommendable::Helpers::Calculations.predict_for(@user.id, @book10.class, @book10.id), -1.0
+    assert_equal Recommendable::Helpers::Calculations.predict_for(@user.id, @movie7.class, @movie7.id), -1.0
+    assert_equal Recommendable::Helpers::Calculations.predict_for(@user.id, @movie8.class, @movie8.id), -1.0
+    assert_equal Recommendable::Helpers::Calculations.predict_for(@user.id, @movie9.class, @movie9.id), 1.0
+    assert_equal Recommendable::Helpers::Calculations.predict_for(@user.id, @movie10.class, @movie10.id), 1.0
+  end
+
+  def teardown
+    Recommendable.redis.flushdb
+  end
+end

data/test/recommendable/helpers/redis_key_mapper_test.rb

@@ -0,0 +1,40 @@
+$LOAD_PATH.unshift File.expand_path('../../test', __FILE__)
+require 'test_helper'
+
+class RedisKeyMapperTest < MiniTest::Unit::TestCase
+  def test_output_of_liked_set_for
+    assert_equal Recommendable::Helpers::RedisKeyMapper.liked_set_for(Movie, 1), 'recommendable:users:1:liked_movies'
+  end
+
+  def test_output_of_disliked_set_for
+    assert_equal Recommendable::Helpers::RedisKeyMapper.disliked_set_for(Movie, 1), 'recommendable:users:1:disliked_movies'
+  end
+
+  def test_output_of_hidden_set_for
+    assert_equal Recommendable::Helpers::RedisKeyMapper.hidden_set_for(Movie, 1), 'recommendable:users:1:hidden_movies'
+  end
+
+  def test_output_of_bookmarked_set_for
+    assert_equal Recommendable::Helpers::RedisKeyMapper.bookmarked_set_for(Movie, 1), 'recommendable:users:1:bookmarked_movies'
+  end
+
+  def test_output_of_recommended_set_for
+    assert_equal Recommendable::Helpers::RedisKeyMapper.recommended_set_for(Movie, 1), 'recommendable:users:1:recommended_movies'
+  end
+
+  def test_output_of_similarity_set_for
+    assert_equal Recommendable::Helpers::RedisKeyMapper.similarity_set_for(1), 'recommendable:users:1:similarities'
+  end
+
+  def test_output_of_liked_by_set_for
+    assert_equal Recommendable::Helpers::RedisKeyMapper.liked_by_set_for(Movie, 1), 'recommendable:movies:1:liked_by'
+  end
+
+  def test_output_of_disliked_by_set_for
+    assert_equal Recommendable::Helpers::RedisKeyMapper.disliked_by_set_for(Movie, 1), 'recommendable:movies:1:disliked_by'
+  end
+
+  def test_output_of_score_set_for
+    assert_equal Recommendable::Helpers::RedisKeyMapper.score_set_for(Movie), 'recommendable:movies:scores'
+  end
+end

data/test/recommendable/ratable/dislikable_test.rb

@@ -0,0 +1,31 @@
+$LOAD_PATH.unshift File.expand_path('../../test', __FILE__)
+require 'test_helper'
+
+class DislikableTest < MiniTest::Unit::TestCase
+  def setup
+    @user = Factory(:user)
+    @friend = Factory(:user)
+    @movie = Factory(:movie)
+  end
+
+  def test_disliked_by_returns_relevant_users
+    assert_empty @movie.disliked_by
+    @user.dislike(@movie)
+    assert_includes @movie.disliked_by, @user
+    refute_includes @movie.disliked_by, @friend
+    @friend.dislike(@movie)
+    assert_includes @movie.disliked_by, @friend
+  end
+
+  def test_disliked_by_count_returns_an_accurate_count
+    assert_empty @movie.disliked_by
+    @user.dislike(@movie)
+    assert_equal @movie.disliked_by_count, 1
+    @friend.dislike(@movie)
+    assert_equal @movie.disliked_by_count, 2
+  end
+
+  def teardown
+    Recommendable.redis.flushdb
+  end
+end

data/test/recommendable/ratable/likable_test.rb

@@ -0,0 +1,31 @@
+$LOAD_PATH.unshift File.expand_path('../../test', __FILE__)
+require 'test_helper'
+
+class LikableTest < MiniTest::Unit::TestCase
+  def setup
+    @user = Factory(:user)
+    @friend = Factory(:user)
+    @movie = Factory(:movie)
+  end
+
+  def test_liked_by_returns_relevant_users
+    assert_empty @movie.liked_by
+    @user.like(@movie)
+    assert_includes @movie.liked_by, @user
+    refute_includes @movie.liked_by, @friend
+    @friend.like(@movie)
+    assert_includes @movie.liked_by, @friend
+  end
+
+  def test_liked_by_count_returns_an_accurate_count
+    assert_empty @movie.liked_by
+    @user.like(@movie)
+    assert_equal @movie.liked_by_count, 1
+    @friend.like(@movie)
+    assert_equal @movie.liked_by_count, 2
+  end
+
+  def teardown
+    Recommendable.redis.flushdb
+  end
+end

data/test/recommendable/ratable_test.rb

@@ -0,0 +1,78 @@
+$LOAD_PATH.unshift File.expand_path('../../test', __FILE__)
+require 'test_helper'
+
+class RatableTest < MiniTest::Unit::TestCase
+  def setup
+    @movie = Factory(:movie)
+    @book = Factory(:book)
+    @rock = Factory(:rock)
+  end
+
+  def test_recommendable_predicate_works
+    assert Movie.recommendable?
+    assert @movie.recommendable?
+    assert Book.recommendable?
+    assert @book.recommendable?
+    refute Rock.recommendable?
+    refute @rock.recommendable?
+  end
+
+  def test_rated_predicate_works
+    refute @movie.rated?
+    user = Factory(:user)
+    user.like(@movie)
+    assert @movie.rated?
+  end
+
+  def test_top_scope_returns_best_things
+    @book2 = Factory(:book)
+    @book3 = Factory(:book)
+    @user = Factory(:user)
+    @friend = Factory(:user)
+
+    @user.like(@book2)
+    @friend.like(@book2)
+    @user.like(@book3)
+    @user.dislike(@book)
+
+    top = Book.top(3)
+    assert_equal top[0], @book2
+    assert_equal top[1], @book3
+    assert_equal top[2], @book
+  end
+
+  def test_removed_from_recommendable_upon_destruction
+    @user = Factory(:user)
+    @friend = Factory(:user)
+    @buddy = Factory(:user)
+    @user.like(@movie)
+    @friend.dislike(@movie)
+    @user.dislike(@book)
+    @friend.like(@book)
+    @buddy.hide(@movie)
+    @buddy.bookmark(@book)
+
+    liked_by_sets = [@movie, @book].map { |obj| Recommendable::Helpers::RedisKeyMapper.liked_by_set_for(obj.class, obj.id) }
+    disliked_by_sets = [@movie, @book].map { |obj| Recommendable::Helpers::RedisKeyMapper.disliked_by_set_for(obj.class, obj.id) }
+    [liked_by_sets, disliked_by_sets].flatten.each { |set| assert_equal Recommendable.redis.scard(set), 1 }
+
+    assert @user.likes?(@movie)
+    assert @user.dislikes?(@book)
+    assert @friend.likes?(@book)
+    assert @friend.dislikes?(@movie)
+    assert @buddy.hides?(@movie)
+    assert @buddy.bookmarks?(@book)
+
+    @movie.destroy
+    @book.destroy
+
+    [liked_by_sets, disliked_by_sets].flatten.each { |set| assert_equal Recommendable.redis.scard(set), 0 }
+
+    assert_empty @buddy.hidden_movies
+    assert_empty @buddy.bookmarked_books
+  end
+
+  def teardown
+    Recommendable.redis.flushdb
+  end
+end

data/test/recommendable/rater/bookmarker_test.rb

@@ -0,0 +1,122 @@
+$LOAD_PATH.unshift File.expand_path('../../test', __FILE__)
+require 'test_helper'
+
+class BookmarkerTest < MiniTest::Unit::TestCase
+  def setup
+    @user = Factory(:user)
+    @movie = Factory(:movie)
+  end
+
+  def test_that_bookmark_adds_to_bookmarked_set
+    refute_includes @user.bookmarked_movie_ids, @movie.id
+    @user.bookmark(@movie)
+    assert_includes @user.bookmarked_movie_ids, @movie.id
+  end
+
+  def test_that_cant_bookmark_already_bookmarked_object
+    assert @user.bookmark(@movie)
+    assert_nil @user.bookmark(@movie)
+  end
+
+  def test_that_cant_bookmark_unratable_object
+    basic_obj = Object.new
+    rock = Factory(:rock)
+
+    assert_raises(ArgumentError) { @user.bookmark(basic_obj) }
+    assert_raises(ArgumentError) { @user.bookmark(rock) }
+  end
+
+  def test_that_bookmarks_returns_true_if_bookmarked
+    refute @user.bookmarks?(@movie)
+    @user.bookmark(@movie)
+    assert @user.bookmarks?(@movie)
+  end
+
+  def test_that_unbookmark_removes_item_from_bookmarked_set
+    @user.bookmark(@movie)
+    assert_includes @user.bookmarked_movie_ids, @movie.id
+    @user.unbookmark(@movie)
+    refute_includes @user.bookmarked_movie_ids, @movie.id
+  end
+
+  def test_that_cant_unbookmark_item_unless_bookmarked
+    assert_nil @user.unbookmark(@movie)
+  end
+
+  def test_that_bookmarks_returns_bookmarked_records
+    refute_includes @user.bookmarks, @movie
+    @user.bookmark(@movie)
+    assert_includes @user.bookmarks, @movie
+  end
+
+  def test_that_dynamic_bookmarked_finder_only_returns_relevant_records
+    book = Factory(:book)
+    @user.bookmark(@movie)
+    @user.bookmark(book)
+
+    refute_includes @user.bookmarked_movies, book
+    refute_includes @user.bookmarked_books, @movie
+  end
+
+  def test_that_bookmarks_count_counts_all_bookmarks
+    book = Factory(:book)
+    movie2 = Factory(:movie)
+
+    @user.bookmark(@movie)
+    @user.bookmark(movie2)
+    @user.bookmark(book)
+
+    assert_equal @user.bookmarks_count, 3
+  end
+
+  def test_that_dynamic_bookmarked_count_methods_only_count_relevant_bookmarks
+    book = Factory(:book)
+    movie2 = Factory(:movie)
+
+    @user.bookmark(@movie)
+    @user.bookmark(movie2)
+    @user.bookmark(book)
+
+    assert_equal @user.bookmarked_movies_count, 2
+    assert_equal @user.bookmarked_books_count, 1
+  end
+
+  def test_that_bookmarks_in_common_with_returns_all_common_bookmarks
+    friend = Factory(:user)
+    movie2 = Factory(:movie)
+    book = Factory(:book)
+    book2 = Factory(:book)
+
+    @user.bookmark(@movie)
+    @user.bookmark(book)
+    @user.bookmark(movie2)
+    friend.bookmark(@movie)
+    friend.bookmark(book)
+    friend.bookmark(book2)
+
+    assert_includes @user.bookmarks_in_common_with(friend), @movie
+    assert_includes @user.bookmarks_in_common_with(friend), book
+    refute_includes @user.bookmarks_in_common_with(friend), movie2
+    refute_includes friend.bookmarks_in_common_with(@user), book2
+  end
+
+  def test_that_dynamic_bookmarked_in_common_with_only_returns_relevant_records
+    friend = Factory(:user)
+    movie2 = Factory(:movie)
+    book = Factory(:book)
+
+    @user.bookmark(@movie)
+    @user.bookmark(book)
+    friend.bookmark(@movie)
+    friend.bookmark(book)
+
+    assert_includes @user.bookmarked_movies_in_common_with(friend), @movie
+    assert_includes @user.bookmarked_books_in_common_with(friend), book
+    refute_includes @user.bookmarked_movies_in_common_with(friend), book
+    refute_includes @user.bookmarked_books_in_common_with(friend), @movie
+  end
+
+  def teardown
+    Recommendable.redis.flushdb
+  end
+end

data/test/recommendable/rater/disliker_test.rb

@@ -0,0 +1,122 @@
+$LOAD_PATH.unshift File.expand_path('../../test', __FILE__)
+require 'test_helper'
+
+class DislikerTest < MiniTest::Unit::TestCase
+  def setup
+    @user = Factory(:user)
+    @movie = Factory(:movie)
+  end
+
+  def test_that_dislike_adds_to_disliked_set
+    refute_includes @user.disliked_movie_ids, @movie.id
+    @user.dislike(@movie)
+    assert_includes @user.disliked_movie_ids, @movie.id
+  end
+
+  def test_that_cant_dislike_already_disliked_object
+    assert @user.dislike(@movie)
+    assert_nil @user.dislike(@movie)
+  end
+
+  def test_that_cant_dislike_unratable_object
+    basic_obj = Object.new
+    rock = Factory(:rock)
+
+    assert_raises(ArgumentError) { @user.dislike(basic_obj) }
+    assert_raises(ArgumentError) { @user.dislike(rock) }
+  end
+
+  def test_that_dislikes_returns_true_if_disliked
+    refute @user.dislikes?(@movie)
+    @user.dislike(@movie)
+    assert @user.dislikes?(@movie)
+  end
+
+  def test_that_undislike_removes_item_from_disliked_set
+    @user.dislike(@movie)
+    assert_includes @user.disliked_movie_ids, @movie.id
+    @user.undislike(@movie)
+    refute_includes @user.disliked_movie_ids, @movie.id
+  end
+
+  def test_that_cant_undislike_item_unless_disliked
+    assert_nil @user.undislike(@movie)
+  end
+
+  def test_that_dislikes_returns_disliked_records
+    refute_includes @user.dislikes, @movie
+    @user.dislike(@movie)
+    assert_includes @user.dislikes, @movie
+  end
+
+  def test_that_dynamic_disliked_finder_only_returns_relevant_records
+    book = Factory(:book)
+    @user.dislike(@movie)
+    @user.dislike(book)
+
+    refute_includes @user.disliked_movies, book
+    refute_includes @user.disliked_books, @movie
+  end
+
+  def test_that_dislikes_count_counts_all_dislikes
+    book = Factory(:book)
+    movie2 = Factory(:movie)
+
+    @user.dislike(@movie)
+    @user.dislike(movie2)
+    @user.dislike(book)
+
+    assert_equal @user.dislikes_count, 3
+  end
+
+  def test_that_dynamic_disliked_count_methods_only_count_relevant_dislikes
+    book = Factory(:book)
+    movie2 = Factory(:movie)
+
+    @user.dislike(@movie)
+    @user.dislike(movie2)
+    @user.dislike(book)
+
+    assert_equal @user.disliked_movies_count, 2
+    assert_equal @user.disliked_books_count, 1
+  end
+
+  def test_that_dislikes_in_common_with_returns_all_common_dislikes
+    friend = Factory(:user)
+    movie2 = Factory(:movie)
+    book = Factory(:book)
+    book2 = Factory(:book)
+
+    @user.dislike(@movie)
+    @user.dislike(book)
+    @user.dislike(movie2)
+    friend.dislike(@movie)
+    friend.dislike(book)
+    friend.dislike(book2)
+
+    assert_includes @user.dislikes_in_common_with(friend), @movie
+    assert_includes @user.dislikes_in_common_with(friend), book
+    refute_includes @user.dislikes_in_common_with(friend), movie2
+    refute_includes friend.dislikes_in_common_with(@user), book2
+  end
+
+  def test_that_dynamic_disliked_in_common_with_only_returns_relevant_records
+    friend = Factory(:user)
+    movie2 = Factory(:movie)
+    book = Factory(:book)
+
+    @user.dislike(@movie)
+    @user.dislike(book)
+    friend.dislike(@movie)
+    friend.dislike(book)
+
+    assert_includes @user.disliked_movies_in_common_with(friend), @movie
+    assert_includes @user.disliked_books_in_common_with(friend), book
+    refute_includes @user.disliked_movies_in_common_with(friend), book
+    refute_includes @user.disliked_books_in_common_with(friend), @movie
+  end
+
+  def teardown
+    Recommendable.redis.flushdb
+  end
+end