randumb 0.2.0 → 0.3.0

data/lib/randumb.rb

@@ -1,54 +1,13 @@
-require 'active_support/core_ext/module/delegation'
-require 'active_record/relation'
-
-module Randumb
-  # https://github.com/rails/rails/blob/master/activerecord/lib/active_record/relation/query_methods.rb
-  module ActiveRecord
-    
-    module Relation
-      
-      def random(max_items = nil)
-        return_first_record = max_items.nil? # see return switch at end
-        max_items ||= 1
-        relation = clone
-      
-        if connection.adapter_name =~ /sqlite/i || connection.adapter_name =~ /postgres/i
-          rand_syntax = "RANDOM()"
-        elsif connection.adapter_name =~ /mysql/i
-          rand_syntax = "RAND()"
-        else
-          raise Exception, "ActiveRecord adapter: '#{connection.adapter_name}' not supported by randumb.  Send a pull request or open a ticket: https://github.com/spilliton/randumb"
-        end
-
-        the_scope = relation.order(rand_syntax)
-        the_scope = the_scope.limit(max_items) unless relation.limit_value && relation.limit_value < max_items
-                
-        # return first record if method was called without parameters
-        if return_first_record
-          the_scope.first
-        else
-          the_scope.all
-        end
-      end
-
-    end # Relation
-    
-    module Base
-      # Class method
-      def random(max_items = nil)
-        relation.random(max_items)
-      end
-    end 
-    
-    
-  end # ActiveRecord
-end # Randumb
+require 'randumb/version'
+require 'randumb/relation'
 
 # Mix it in
 class ActiveRecord::Relation
   include Randumb::ActiveRecord::Relation
+  include Randumb::ActiveRecord::MethodMissingMagicks
 end
 
 class ActiveRecord::Base
   extend Randumb::ActiveRecord::Base
+  extend Randumb::ActiveRecord::MethodMissingMagicks
 end

data/lib/randumb/relation.rb

@@ -0,0 +1,160 @@
+require 'active_support/core_ext/module/delegation'
+require 'active_record/relation'
+
+module Randumb
+  # https://github.com/rails/rails/blob/master/activerecord/lib/active_record/relation/query_methods.rb
+  module ActiveRecord
+    
+    module Relation
+
+      # If the max_items argument is omitted, one random entity will be returned.
+      # If you provide the integer argument, you will get back an array of records.
+      def random(max_items = nil)
+        random_weighted(nil, max_items)
+      end
+
+      # If ranking_column is provided, that named column wil be multiplied
+      # by a random number to determine probability of order. The ranking column must be numeric.
+      def random_weighted(ranking_column, max_items = nil)
+        relation = clone
+
+        # postgres won't let you do an order_by when also doing a distinct
+        # let's just use the in-memory option in this case
+        if relation.uniq_value && connection.adapter_name =~ /postgres/i
+          if ranking_column 
+            raise Exception, "random_weighted: not possible when using .uniq and the postgres db adapter"
+          else
+            return random_by_id_shuffle(max_items)
+          end
+        end
+
+        # ensure a valid column for ranking
+        if ranking_column
+          column_data = @klass.columns_hash[ranking_column.to_s]
+          raise ArgumentError.new("random_weighted: #{ranking_column} is not a column on #{@klass.table_name}!") unless column_data
+          raise ArgumentError.new("random_weighted: #{ranking_column} is not a numeric column on #{@klass.table_name}!") unless [:integer, :float].include?(column_data.type)
+        end
+
+        # choose the right syntax
+        if connection.adapter_name =~ /(sqlite|postgres)/i
+          rand_syntax = "RANDOM()"
+        elsif connection.adapter_name =~ /mysql/i
+          rand_syntax = "RAND()"
+        else
+          raise Exception, "ActiveRecord adapter: '#{connection.adapter_name}' not supported by randumb.  Send a pull request or open a ticket: https://github.com/spilliton/randumb"
+        end
+
+        order_clause =  if ranking_column.nil?
+                          rand_syntax
+                        else
+                          if connection.adapter_name =~ /sqlite/i
+                            # computer multiplication is faster than division I was once taught...so translate here
+                            max_int = 9223372036854775807.0
+                            multiplier = 1.0 / max_int 
+                            "(#{ranking_column} * ABS(#{rand_syntax} * #{multiplier}) ) DESC"
+                          else
+                            "(#{ranking_column} * #{rand_syntax}) DESC"
+                          end
+                        end
+
+        the_scope = relation.order(order_clause)
+
+        # override the limit if they are requesting multiple records
+        if max_items && (!relation.limit_value || relation.limit_value > max_items)
+          the_scope = the_scope.limit(max_items)
+        end
+
+        # return first record if method was called without parameters
+        if max_items.nil?
+          the_scope.first
+        else
+          the_scope.all
+        end
+      end
+
+
+      # This was my first implementation, adding it as an option for people to use
+      # and to fall back on for pesky DB one off situations...
+      #  https://github.com/spilliton/randumb/issues/7
+      def random_by_id_shuffle(max_items = nil)
+        return_first_record = max_items.nil?# see return switch at end
+        max_items ||= 1
+        relation = clone
+      
+        # store these for including on final scope
+        original_includes = relation.includes_values
+        original_selects = relation.select_values
+        
+        # clear these for our id only query
+        relation.select_values = []
+        relation.includes_values = []
+      
+        # do original query but only for id field
+        id_only_relation = relation.select("#{table_name}.id")
+        id_results = connection.select_all(id_only_relation.to_sql)
+      
+        # get requested number of random ids
+        if max_items == 1 && id_results.length > 0
+          ids = [ id_results[ rand(id_results.length) ]['id'] ]
+        else
+          ids = id_results.shuffle![0,max_items].collect!{ |h| h['id'] }
+        end
+  
+        # build scope for final query
+        the_scope = klass.includes(original_includes)
+
+        # specifying empty selects caused bug in rails 3.0.0/3.0.1
+        the_scope = the_scope.select(original_selects) unless original_selects.empty? 
+
+        # get the records and shuffle since the order of the ids
+        # passed to find_all_by_id isn't retained in the result set
+        records = the_scope.find_all_by_id(ids).shuffle!
+                
+        # return first record if method was called without parameters
+        if return_first_record
+          records.first
+        else
+          records
+        end
+      end
+
+    end 
+
+    
+    # Class methods
+    module Base
+      def random(max_items = nil)
+        relation.random(max_items)
+      end
+
+      def random_weighted(ranking_column, max_items = nil)
+        relation.random_weighted(ranking_column, max_items)
+      end
+
+      def random_by_id_shuffle(max_items = nil)
+        relation.random_by_id_shuffle(max_items)
+      end
+    end 
+
+
+    # These get registered as class and instance methods
+    module MethodMissingMagicks
+      def method_missing(symbol, *args)
+        if symbol.to_s =~ /^random_weighted_by_(\w+)$/
+          random_weighted($1, *args)
+        else
+          super
+        end
+      end
+
+      def respond_to?(symbol, include_private=false)
+        if symbol.to_s =~ /^random_weighted_by_(\w+)$/
+          true
+        else
+          super
+        end
+      end
+    end
+
+  end # ActiveRecord
+end # Randumb

data/lib/randumb/version.rb

@@ -0,0 +1,3 @@
+module Randumb
+  VERSION = "0.3.0"
+end

data/test/models/album.rb

@@ -0,0 +1,4 @@
+class Album < ActiveRecord::Base
+  belongs_to :artist
+
+end

data/test/models/artist.rb

@@ -0,0 +1,5 @@
+class Artist < ActiveRecord::Base
+  has_many :albums
+  
+  scope :at_least_three_views, where("views >= 3")
+end

data/test/models/factories.rb

@@ -0,0 +1,13 @@
+FactoryGirl.define do
+  factory :artist do
+    name { Faker::Lorem.words(3).join(' ') }
+    views  { Random.rand(50) }
+    rating { Random.rand(100) / 100 }
+  end
+
+  factory :album do
+    name { Faker::Lorem.words(3).join(' ') }
+    views { Random.rand(50) }
+  end
+
+end

data/test/randumb_test.rb

@@ -0,0 +1,193 @@
+$:.unshift '.'; require File.dirname(__FILE__) + '/test_helper'
+
+class RandumbTest < Test::Unit::TestCase
+
+  def assert_equal_for_both_methods(expected, obj, params = nil)
+    assert_equal expected, obj.send(:random, params), "when calling random"
+    assert_equal expected, obj.send(:random_by_id_shuffle, params), "when calling random_by_id_shuffle"
+  end
+
+
+  should "should return empty when no record in table" do
+    assert_equal 0, Artist.count
+
+    assert_equal_for_both_methods nil, Artist
+    # above is equivalent to:
+    # assert_equal nil, Artist.random
+    # assert_equal nil, Artist.random_by_id_shuffle
+
+    assert_equal_for_both_methods [], Artist, 1
+    # above is equivalent to:
+    # assert_equal [], Artist.random(1)
+    # assert_equal [], Artist.random_by_id_shuffle(1)
+
+    assert_equal_for_both_methods nil, Artist.limit(50)
+  end
+
+  context "1 record in the table" do
+    setup do
+      @high_on_fire = FactoryGirl.create(:artist, :name => "High On Fire", :views => 1)
+    end
+
+    should "select only 1 record even when you request more" do
+      assert_equal 1, Artist.count
+
+      assert_equal_for_both_methods @high_on_fire, Artist
+      assert_equal_for_both_methods [@high_on_fire], Artist, 1
+      assert_equal_for_both_methods [@high_on_fire], Artist, 30
+    end
+
+    should "not return a record that doesnt match where" do
+      assert_equal_for_both_methods nil, Artist.where(:name => "The Little Gentlemen")
+    end
+
+    context "3 records in table" do
+      setup do
+        @fiona_apple = FactoryGirl.create(:artist, :name => "Fiona Apple", :views => 3)
+        @magnetic_fields = FactoryGirl.create(:artist, :name => "The Magnetic Fields", :views => 2)
+      end
+
+      should "apply randomness after other orders when using sql method" do
+        assert_equal @fiona_apple, Artist.order("views desc").random
+        assert_equal [@fiona_apple, @magnetic_fields], Artist.order("views desc").random(2)
+      end
+
+      should "take smaller limit if one is provided in scope" do
+        assert_equal 2, Artist.limit(2).random(3).length
+        assert_equal 2, Artist.limit(2).random_by_id_shuffle(3).length
+
+        assert_equal 2, Artist.limit(3).random(2).length
+        assert_equal 2, Artist.limit(3).random_by_id_shuffle(2).length
+      end
+
+      should "respect selecting certain columns" do
+        assert_equal 3, Artist.find(@fiona_apple.id).views
+
+        artists = Artist.select(:name).random(3)
+        assert_equal false, artists.first.name.nil?
+        assert_raise (ActiveModel::MissingAttributeError) {artists.first.views}
+
+        artists = Artist.select(:name).random_by_id_shuffle(3)
+        assert_equal false, artists.first.name.nil?
+        assert_raise (ActiveModel::MissingAttributeError) {artists.first.views}
+      end
+
+      should "respect scopes" do
+        assert_equal_for_both_methods [@fiona_apple], Artist.at_least_three_views, 3
+      end
+
+      should "select only as many as in the db if we request more" do
+        random_artists = Artist.random(10)
+        assert_equal 3, random_artists.length
+        assert_equal true, random_artists.include?(@high_on_fire)
+        assert_equal true, random_artists.include?(@fiona_apple)
+        assert_equal true, random_artists.include?(@magnetic_fields)
+
+        random_artists = Artist.random_by_id_shuffle(10)
+        assert_equal 3, random_artists.length
+        assert_equal true, random_artists.include?(@high_on_fire)
+        assert_equal true, random_artists.include?(@fiona_apple)
+        assert_equal true, random_artists.include?(@magnetic_fields)
+      end
+
+      context "with some albums" do
+        setup do
+          @tidal = FactoryGirl.create(:album, :name => "Tidal", :artist => @fiona_apple)
+          @extraordinary_machine = FactoryGirl.create(:album, :name => "Extraordinary Machine", :artist => @fiona_apple)
+          @sixty_nine_love_songs = FactoryGirl.create(:album, :name => "69 Love Songs", :artist => @magnetic_fields)
+          @snakes_for_the_divine = FactoryGirl.create(:album, :name => "Snakes For the Divine", :artist => @high_on_fire)
+        end
+
+
+        should "work with includes for default method" do
+          artists = Artist.includes(:albums).random(10)
+          fiona_apple = artists.find { |a| a.name == "Fiona Apple" }
+          # if I add a new album now, it shouldn't be in the albums assocation yet b/c it was already loaded
+          FactoryGirl.create(:album, :name => "When The Pawn", :artist => @fiona_apple)
+
+          assert_equal 2, fiona_apple.albums.length
+          assert_equal 3, @fiona_apple.reload.albums.length
+        end
+
+        should "work with includes for shuffle method" do
+          artists = Artist.includes(:albums).random_by_id_shuffle(10)
+          fiona_apple = artists.find { |a| a.name == "Fiona Apple" }
+          # if I add a new album now, it shouldn't be in the albums assocation yet b/c it was already loaded
+          FactoryGirl.create(:album, :name => "When The Pawn", :artist => @fiona_apple)
+
+          assert_equal 2, fiona_apple.albums.length
+          assert_equal 3, @fiona_apple.reload.albums.length
+        end
+
+        should "work with joins for default method" do
+          albums = Album.joins(:artist).where("artists.views > 1").random(3)
+
+          assert_equal 3, albums.length
+          assert_equal false, albums.include?(@snakes_for_the_divine)
+          assert_equal true, albums.include?(@tidal)
+          assert_equal true, albums.include?(@extraordinary_machine)
+          assert_equal true, albums.include?(@sixty_nine_love_songs)
+        end
+
+        should "work with joins for shuffle method" do
+          albums = Album.joins(:artist).where("artists.views > 1").random_by_id_shuffle(3)
+
+          assert_equal 3, albums.length
+          assert_equal false, albums.include?(@snakes_for_the_divine)
+          assert_equal true, albums.include?(@tidal)
+          assert_equal true, albums.include?(@extraordinary_machine)
+          assert_equal true, albums.include?(@sixty_nine_love_songs)
+        end
+
+        should "work with uniq" do
+          assert_equal 2, Artist.uniq.random(2).length
+          assert_equal 2, Artist.uniq.random_by_id_shuffle(2).length
+
+          assert_not_nil Artist.uniq.random
+          assert_not_nil Artist.uniq.random_by_id_shuffle
+        end
+
+      end
+
+    end
+
+  end
+
+  context "2 records in table" do
+    setup do
+      @hum = FactoryGirl.create(:artist, :name => "Hum", :views => 3)
+      @minutemen = FactoryGirl.create(:artist, :name => "Minutemen", :views => 2)
+    end
+
+    should "eventually render the 2 possible orders using default method" do
+      order1 = [@hum, @minutemen]
+      order2 = [@minutemen, @hum]
+      order1_found = false
+      order2_found = false
+      100.times do
+        order = Artist.random(2)
+        order1_found = true if order == order1
+        order2_found = true if order == order2
+        break if order1_found && order2_found
+      end
+      assert order1_found
+      assert order2_found
+    end
+
+    should "eventually render the 2 possible orders using shuffle method" do
+      order1 = [@hum, @minutemen]
+      order2 = [@minutemen, @hum]
+      order1_found = false
+      order2_found = false
+      100.times do
+        order = Artist.random_by_id_shuffle(2)
+        order1_found = true if order == order1
+        order2_found = true if order == order2
+        break if order1_found && order2_found
+      end
+      assert order1_found
+      assert order2_found
+    end
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,67 @@
+$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'factory_girl'
+require 'faker'
+require 'active_record'
+require 'active_support/dependencies'
+require 'active_support/core_ext/logger'
+# require 'active_record/fixtures'
+require 'randumb'
+
+MODELS_PATH = File.join(File.dirname(__FILE__), 'models')
+
+
+ActiveRecord::Base.logger = Logger.new(STDERR)
+ActiveRecord::Base.logger.level = Logger::WARN
+
+config = YAML::load(File.open(File.expand_path("../databases.yml", __FILE__)))
+version = ActiveRecord::VERSION::STRING
+driver = (ENV["DB"] or "sqlite3").downcase
+in_memory = config[driver]["database"] == ":memory:"
+    
+# http://about.travis-ci.org/docs/user/database-setup/
+commands = {
+  "mysql"    => "mysql -e 'create database randumb_test;'",
+  "postgres" => "psql -c 'create database randumb_test;' -U postgres"
+}
+%x{#{commands[driver] || true}}
+    
+ActiveRecord::Base.establish_connection config[driver]
+puts "Using #{RUBY_VERSION} AR #{version} with #{driver}"
+
+
+ActiveRecord::Base.connection.create_table(:artists, :force => true) do |t|
+  t.string   "name"
+  t.integer  "views"
+  t.float    "rating"
+  t.datetime "created_at"
+  t.datetime "updated_at"
+end
+  
+ActiveRecord::Base.connection.create_table(:albums, :force => true) do |t|
+  t.string  "name"
+  t.integer "views"
+  t.integer "artist_id"
+  t.datetime "created_at"
+  t.datetime "updated_at"
+end
+  
+# setup models for lazy load
+dep = defined?(ActiveSupport::Dependencies) ? ActiveSupport::Dependencies : ::Dependencies
+dep.autoload_paths.unshift MODELS_PATH
+
+# load factories now
+require 'test/models/factories'
+
+# clear db for every test
+class Test::Unit::TestCase
+
+  def setup
+    Artist.delete_all
+    Album.delete_all
+  end
+
+end
+

data/test/weighted_test.rb

@@ -0,0 +1,125 @@
+$:.unshift '.'; require File.dirname(__FILE__) + '/test_helper'
+
+class WeightedTest < Test::Unit::TestCase
+
+  should "raise exception when called with a non-existent column" do
+    assert_raises(ArgumentError) do
+      Artist.random_weighted(:blah)
+    end
+    assert_raises(ArgumentError) do
+      Artist.random_weighted_by_blah
+    end
+  end
+
+  should "raise exception when called with a non-numeric column" do
+    assert_raises(ArgumentError) do
+      Artist.random_weighted(:name)
+    end
+    assert_raises(ArgumentError) do
+      Artist.random_weighted_by_name
+    end
+  end
+
+  if ENV["DB"] == "postgres"
+    should "raise exception if being called with uniq/postgres" do
+      assert_raises(Exception) do
+        Artist.uniq.random_weighted(:name)
+      end
+    end
+  else
+    should "work with uniq if not postgres" do
+      assert_nil Artist.uniq.random_weighted_by_views
+    end
+  end
+
+  should "not blow up with integer columns and float column types" do
+    assert_nil Artist.random_weighted_by_views
+    assert_nil Artist.random_weighted_by_rating
+  end
+
+  should "not interfere with active record dynamic methods that use method_missing" do
+    @artist = FactoryGirl.create(:artist, :name => 'Spiritualized')
+    assert_equal @artist, Artist.find_by_name('Spiritualized')
+  end
+
+  should "respond to respond_to?" do
+    assert Artist.respond_to?(:random_weighted_by_views)
+    assert Artist.respond_to?(:random_weighted_by_xxxxxx)
+    assert Artist.at_least_three_views.respond_to?(:random_weighted_by_xxxxxx)
+  end
+
+  should "not interfere with active record dynamic methods that use respond_to?" do
+    assert Artist.respond_to?(:find_by_name)
+  end
+
+
+  context "order by ranking_column" do
+    setup do
+      @view_counts = [1, 2, 3, 4, 5]
+      @view_counts.each { |views| FactoryGirl.create(:artist, :views => views) }
+    end
+
+    should "order by ranking column with explicit method call" do
+      assert_hits_per_views do
+        Artist.random_weighted("views").views
+      end
+    end
+
+    should "order by ranking column with method_missing" do
+      assert_hits_per_views do
+        Artist.random_weighted_by_views.views
+      end
+    end
+
+    should "order by ranking column with explicit method call and max_items" do
+      assert_hits_per_views do
+        result = Artist.random_weighted("views", 5)
+        assert(result.size == 5)
+        result.first.views
+      end
+    end
+
+    should "order by ranking column with method_missing using max_items" do
+      assert_hits_per_views do
+        result = Artist.random_weighted_by_views(10)
+        assert(result.size == 5)
+        result.first.views
+      end
+    end
+
+    should "LAST order should fail" do
+      assert_raises(MiniTest::Assertion) do
+        assert_hits_per_views do
+          result = Artist.random_weighted_by_views(3)
+          assert(result.size == 3)
+          result.last.views
+        end
+      end
+    end
+
+    should "order by ranking column with method_missing using 1 max_items" do
+      assert_hits_per_views do
+        result = Artist.random_weighted_by_views(1)
+        assert(result.size == 1)
+        result.first.views
+      end
+    end
+
+    def assert_hits_per_views
+      hits_per_views = Hash.new
+      @view_counts.each { |views| hits_per_views[views] = 0 }
+      
+      1000.times do
+        hits_per_views[yield] += 1
+      end
+      last_count = 0
+      @view_counts.each do |views|
+        hits = hits_per_views[views]
+        assert(hits >= last_count, "#{hits} > #{last_count} : There were an unexpected number of visits: #{hits_per_views.to_yaml}")
+        last_count = hits
+      end
+    end
+  end
+
+
+end

metadata

@@ -2,7 +2,7 @@
 name: randumb
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Zachary Kloepping
@@ -10,19 +10,85 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-05-06 00:00:00 Z
+date: 2012-07-07 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: rspec
+  name: activesupport
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 3.0.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 3.0.0
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: pg
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
         version: "0"
   type: :development
-  version_requirements: *id001
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: shoulda
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: factory_girl
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "3.0"
+  type: :development
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: faker
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id007
 description: 
 email: 
 executables: []
@@ -32,7 +98,15 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- lib/randumb/relation.rb
+- lib/randumb/version.rb
 - lib/randumb.rb
+- test/models/album.rb
+- test/models/artist.rb
+- test/models/factories.rb
+- test/randumb_test.rb
+- test/test_helper.rb
+- test/weighted_test.rb
 homepage: https://github.com/spilliton/randumb
 licenses: []
 
@@ -60,5 +134,10 @@ rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Adds the ability to pull random records from ActiveRecord
-test_files: []
-
+test_files: 
+- test/models/album.rb
+- test/models/artist.rb
+- test/models/factories.rb
+- test/randumb_test.rb
+- test/test_helper.rb
+- test/weighted_test.rb