From d0f4fba1848ecdc7a47c58a4984f330b191a4fad Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Micha=C3=ABl=20Villeneuve?= Date: Fri, 8 Dec 2023 11:49:09 +0100 Subject: [PATCH] Lot of testing and some improvements --- .rubocop.yml | 5 + Gemfile.lock | 32 +++++ Rakefile | 9 +- lib/statisfy/configuration.rb | 8 +- lib/statisfy/counter.rb | 85 +++++++------ statisfy.gemspec | 8 ++ test/factories/organisation.rb | 5 + test/factories/user.rb | 6 + test/helper.rb | 21 ++++ test/statisfy_test.rb | 219 +++++++++++++++++++++++++++++++++ 10 files changed, 358 insertions(+), 40 deletions(-) create mode 100644 test/factories/organisation.rb create mode 100644 test/factories/user.rb create mode 100644 test/helper.rb create mode 100644 test/statisfy_test.rb diff --git a/.rubocop.yml b/.rubocop.yml index e1d557c..f355bcf 100644 --- a/.rubocop.yml +++ b/.rubocop.yml @@ -1,5 +1,7 @@ AllCops: TargetRubyVersion: 3.2.2 + Exclude: + - 'test/**/*' Style/StringLiterals: Enabled: true @@ -17,6 +19,9 @@ Metrics/CyclomaticComplexity: Style/FrozenStringLiteralComment: Enabled: false +Metrics/PerceivedComplexity: + Enabled: false + Metrics/ModuleLength: Enabled: false diff --git a/Gemfile.lock b/Gemfile.lock index 0aca73b..5ed4a80 100644 --- a/Gemfile.lock +++ b/Gemfile.lock @@ -6,13 +6,36 @@ PATH GEM remote: https://rubygems.org/ specs: + activemodel (7.0.4.3) + activesupport (= 7.0.4.3) + activerecord (7.0.4.3) + activemodel (= 7.0.4.3) + activesupport (= 7.0.4.3) + activesupport (7.0.4.3) + concurrent-ruby (~> 1.0, >= 1.0.2) + i18n (>= 1.6, < 2) + minitest (>= 5.1) + tzinfo (~> 2.0) ast (2.4.2) + coderay (1.1.3) + concurrent-ruby (1.2.2) + connection_pool (2.4.1) + i18n (1.14.1) + concurrent-ruby (~> 1.0) json (2.6.3) + method_source (1.0.0) + minitest (5.20.0) parallel (1.22.1) parser (3.2.2.0) ast (~> 2.4.1) + pry (0.14.2) + coderay (~> 1.1) + method_source (~> 1.0) rainbow (3.1.1) rake (13.0.6) + redis (4.8.1) + redis-client (0.17.0) + connection_pool regexp_parser (2.8.2) rexml (3.2.6) rubocop (1.49.0) @@ -28,14 +51,23 @@ GEM rubocop-ast (1.28.0) parser (>= 3.2.1.0) ruby-progressbar (1.13.0) + sqlite3 (1.6.9-arm64-darwin) + tzinfo (2.0.6) + concurrent-ruby (~> 1.0) unicode-display_width (2.4.2) PLATFORMS arm64-darwin-22 DEPENDENCIES + activerecord (~> 7.0.4.3) + activesupport (~> 7.0.4.3) + pry (~> 0.14.1) rake (~> 13.0) + redis (~> 4.8.1) + redis-client (~> 0.17.0) rubocop (~> 1.21) + sqlite3 (~> 1.6.9) statisfy! BUNDLED WITH diff --git a/Rakefile b/Rakefile index 1924143..cc27eab 100644 --- a/Rakefile +++ b/Rakefile @@ -2,7 +2,14 @@ require "bundler/gem_tasks" require "rubocop/rake_task" +require "rake/testtask" RuboCop::RakeTask.new -task default: :rubocop +Rake::TestTask.new do |t| + t.libs << "test" + t.test_files = FileList["test/**/**.rb"] +end + +desc "Run tests" +task default: :test \ No newline at end of file diff --git a/lib/statisfy/configuration.rb b/lib/statisfy/configuration.rb index 43b24b0..dd37d73 100644 --- a/lib/statisfy/configuration.rb +++ b/lib/statisfy/configuration.rb @@ -1,6 +1,12 @@ module Statisfy class Configuration - attr_accessor :redis_client, :append_to_counters, :default_async_method, :counters_path + attr_accessor( + :default_scopes, + :redis_client, + :append_to_counters, + :default_async_method, + :counters_path + ) def initialize @default_async_method = :perform_async diff --git a/lib/statisfy/counter.rb b/lib/statisfy/counter.rb index e8d664c..22f3e3d 100644 --- a/lib/statisfy/counter.rb +++ b/lib/statisfy/counter.rb @@ -32,6 +32,10 @@ def count(args = {}) class_eval(&Statisfy.configuration.append_to_counters) if Statisfy.configuration.append_to_counters.present? end + def aggregate(args = {}) + count(args.merge(type: :average)) + end + # # This method serves as a syntactic sugar # The below methods could be written directly in the class definition @@ -39,7 +43,7 @@ def count(args = {}) # def apply_default_counter_options(args) define_method(:identifier, args[:uniq_by] || -> { params["id"] }) - define_method(:scopes, args[:scopes]) if args[:scopes].present? + define_method(:scopes, args[:scopes] || Statisfy.configuration.default_scopes || -> { [] }) define_method(:if_async, args[:if_async] || -> { true }) define_method(:decrement?, args[:decrement_if] || -> { false }) define_method(:value, args[:value] || -> {}) @@ -56,23 +60,31 @@ def apply_default_counter_options(args) # @param scope: the scope of the counter (an Organisation or a Department) # @param month: the month for which you want the value of the counter (optional) # - def value(scope:, month: nil) + def value(scope: nil, month: nil) + month = month&.strftime("%Y-%m") if month.present? if const_get(:COUNTER_TYPE) == :average - average_for(scope:, month:) + average(scope:, month:) else - number_of_elements_in(scope:, month:) + size(scope:, month:) end end - def number_of_elements_in(scope:, month: nil, group: nil) - redis_client.scard(key_for(group:, scope:, month:)) + def size(scope: nil, month: nil) + redis_client.scard(key_for(scope:, month:)) end # # Returns the list of elements in the set (in case you use .append and not .increment) # - def elements_in(scope:, month: nil, group: nil) - redis_client.lrange(key_for(group:, scope:, month:), 0, -1) + def elements_in(scope: nil, month: nil) + redis_client.lrange(key_for(scope:, month:), 0, -1) + end + + def sum(scope: nil, month: nil) + stored_values = elements_in(scope:, month:) + return 0 if stored_values.empty? + + stored_values.map(&:to_i).reduce(:+) end # @@ -80,9 +92,10 @@ def elements_in(scope:, month: nil, group: nil) # Example: # append(value: 1) # append(value: 2) - # average_for(scope: Organisation.first) # => 1.5 + # average + # => 1.5 # - def average_for(scope:, month: nil) + def average(scope: nil, month: nil) stored_values = elements_in(scope:, month:) return 0 if stored_values.empty? @@ -92,13 +105,12 @@ def average_for(scope:, month: nil) # # This is the name of the Redis key that will be used to store the counter # - def key_for(scope:, month: nil, group: nil) + def key_for(scope:, month: nil) { counter: name.demodulize.underscore, - group:, month:, - scope_type: scope.class.name, - scope_id: scope.id + scope_type: scope&.class&.name, + scope_id: scope&.id }.to_json end @@ -118,22 +130,22 @@ def redis_client # @param start_at: the date from which you want to start counting (optional) # @param stop_at: the date at which you want to stop counting (optional) # - def values_grouped_by_month(scope:, start_at: nil, stop_at: nil) - x_months = 24 + def values_grouped_by_month(scope: nil, start_at: nil, stop_at: nil) + n_months = 24 if start_at.present? || scope&.created_at.present? start_at ||= scope.created_at - x_months = ((Time.zone.today.year * 12) + Time.zone.today.month) - ((start_at.year * 12) + start_at.month) + n_months = (Time.zone.today.year + Time.zone.today.month) - (start_at.year + start_at.month) end - relevant_months = (0..x_months).map do |i| - (x_months - i).months.ago.beginning_of_month + relevant_months = (0..n_months).map do |i| + (n_months - i).months.ago.beginning_of_month end relevant_months .filter { |month| stop_at.blank? || month < stop_at } .to_h do |month| - [month.strftime("%m/%Y"), value(scope:, month: month.strftime("%Y-%m")).round(2)] + [month.strftime("%m/%Y"), value(scope:, month:).round(2)] end end # rubocop:enable Metrics/AbcSize @@ -155,24 +167,25 @@ def initialize_with(resource, options = {}) # Returns the list of all the keys of this counter for a given scope (optional) # and a given month (optional) # - def all_keys(scope: nil, month: nil, group: nil) + # rubocop:disable Metrics/AbcSize + def all_keys(scope: nil, month: nil) redis_client.keys("*\"counter\":\"#{name.demodulize.underscore}\"*").filter do |json| key = JSON.parse(json) scope_matches = scope.nil? || (key["scope_type"] == scope.class.name && key["scope_id"] == scope.id) month_matches = month.nil? || key["month"] == month - group_matches = group.nil? || key["group"] == group - scope_matches && month_matches && group_matches + scope_matches && month_matches end end + # rubocop:enable Metrics/AbcSize # # This allows to reset all the counters for a given scope (optional) # and a given month (optional) # - def reset(scope: nil, month: nil, group: nil) - all_keys(scope:, month:, group:).each do |key| + def reset(scope: nil, month: nil) + all_keys(scope:, month:).each do |key| redis_client.del(key) end @@ -183,17 +196,13 @@ def reset(scope: nil, month: nil, group: nil) protected def scopes_with_global - (scopes + [Department.new]).flatten.compact + scopes.flatten.compact << nil end def month_to_set params["created_at"].to_date.strftime("%Y-%m") end - def scopes - [subject.department, subject.organisation] - end - def process_event return unless if_async @@ -208,22 +217,22 @@ def process_event # This allows to iterate over all the counters that need to be updated # (in general the Department(s) and Organisation(s) for both the current month and the global counter) # - def all_counters_of(group:) + def all_counters [month_to_set, nil].each do |month| scopes_with_global.each do |scope| - yield self.class.key_for(group:, scope:, month:), identifier + yield self.class.key_for(scope:, month:), identifier end end end - def increment(group: nil) - all_counters_of(group:) do |key, id| + def increment + all_counters do |key, id| self.class.redis_client.sadd?(key, id) end end - def decrement(group: nil) - all_counters_of(group:) do |key, id| + def decrement + all_counters do |key, id| self.class.redis_client.srem?(key, id) end end @@ -231,8 +240,8 @@ def decrement(group: nil) # # To be used to store a list of values instead of a basic counter # - def append(value:, group: nil) - all_counters_of(group:) do |key| + def append(value:) + all_counters do |key| self.class.redis_client.rpush(key, value) end end diff --git a/statisfy.gemspec b/statisfy.gemspec index 0872278..5f09695 100644 --- a/statisfy.gemspec +++ b/statisfy.gemspec @@ -3,6 +3,7 @@ Gem::Specification.new do |s| s.name = "statisfy" s.version = "0.0.1" + s.required_ruby_version = ">= 3.2.0" s.date = "2023-12-07" s.summary = "A performant and flexible counter solution" s.description = "A performant and flexible counter solution that allows to make statistics on your models" @@ -11,4 +12,11 @@ Gem::Specification.new do |s| s.email = "contact@michaelvilleneuve.fr" s.files = Dir["lib/**/*"] s.license = "MIT" + s.add_development_dependency "activerecord", "~> 7.0.4.3" + s.add_development_dependency "activesupport", "~> 7.0.4.3" + s.add_development_dependency "redis", "~> 4.8.1" + s.add_development_dependency "redis-client", "~> 0.17.0" + s.add_development_dependency "rubocop", "~> 1.49.0" + s.add_development_dependency "sqlite3", "~> 1.6.9" + s.add_development_dependency "pry", "~> 0.14.1" end diff --git a/test/factories/organisation.rb b/test/factories/organisation.rb new file mode 100644 index 0000000..0fc119c --- /dev/null +++ b/test/factories/organisation.rb @@ -0,0 +1,5 @@ +require "active_record" + +class Organisation < ActiveRecord::Base + has_many :users +end \ No newline at end of file diff --git a/test/factories/user.rb b/test/factories/user.rb new file mode 100644 index 0000000..4673337 --- /dev/null +++ b/test/factories/user.rb @@ -0,0 +1,6 @@ +require "active_record" +require_relative "organisation" + +class User < ActiveRecord::Base + belongs_to :organisation +end \ No newline at end of file diff --git a/test/helper.rb b/test/helper.rb new file mode 100644 index 0000000..03328cf --- /dev/null +++ b/test/helper.rb @@ -0,0 +1,21 @@ +require "active_record" +require "redis" +require "statisfy" + +ActiveRecord::Base.establish_connection adapter: "sqlite3", database: ":memory:" + +ActiveRecord::Base.connection.create_table :users, force: true do |t| + t.string(:name) + t.integer(:organisation_id) + t.integer(:salary) + t.timestamps +end + +ActiveRecord::Base.connection.create_table :organisations, force: true do |t| + t.string(:name) + t.timestamps +end + +Statisfy.configure do |config| + config.redis_client = Redis.new +end diff --git a/test/statisfy_test.rb b/test/statisfy_test.rb new file mode 100644 index 0000000..393221f --- /dev/null +++ b/test/statisfy_test.rb @@ -0,0 +1,219 @@ +$VERBOSE = nil + +require "minitest/autorun" +require "statisfy" +require "active_support" +require_relative "helper" + +require_relative "factories/user" +require_relative "factories/organisation" + +class StatisfyTest < ActiveSupport::TestCase + setup do + Redis.new.flushall + User.delete_all + Organisation.delete_all + end + + test "it is a module" do + assert_kind_of Module, Statisfy + end + + test "it can count a resource" do + class UserCounter + include Statisfy::Counter + + count every: :user_created + end + + User.create! + assert UserCounter.value == 1 + end + + test "it can count a resource with a scope" do + class UserCounter + include Statisfy::Counter + + count every: :user_created, scopes: -> { [user.organisation] } + end + + apple = Organisation.create!(name: "Apple") + microsoft = Organisation.create!(name: "Microsoft") + + User.create!(name: "Steve", organisation: apple) + User.create!(name: "Bill", organisation: microsoft) + + assert UserCounter.value(scope: apple) == 1 + assert UserCounter.value(scope: microsoft) == 1 + assert UserCounter.value == 2 + end + + test "it can count a resource with a scope and a month" do + class UserCounter + include Statisfy::Counter + + count every: :user_created, scopes: -> { [user.organisation] } + end + + apple = Organisation.create!(name: "Apple") + microsoft = Organisation.create!(name: "Microsoft") + + User.create!(name: "Steve", organisation: apple) + User.create!(name: "Bill", organisation: microsoft) + + assert UserCounter.value(scope: apple, month: Date.today) == 1 + assert UserCounter.value(scope: microsoft, month: Date.today) == 1 + assert UserCounter.value(month: Date.today) == 2 + end + + test "#values_grouped_by_month creates a hash of values grouped by month" do + class UserCounter + include Statisfy::Counter + + count every: :user_created, scopes: -> { [user.organisation] } + end + + every_month = (0..24).map do |i| + creation_date = (24 - i).months.ago.beginning_of_month + between_2_and_5 = rand(2..5) + + between_2_and_5.times do + User.create!(created_at: creation_date) + end + end + + assert UserCounter.values_grouped_by_month(stop_at: 1.month.ago).values.all? { |v| v >= 2 && v <= 5 } + end + + test "if option prevents running counter" do + class UserCounterFalse + include Statisfy::Counter + + count every: :user_created, if: -> { false } + end + + class UserCounter + include Statisfy::Counter + + count every: :user_created, if: -> { true } + end + + User.create! + assert UserCounterFalse.value == 0 + assert UserCounter.value == 1 + end + + test "if_async option prevents running counter" do + class UserCounterFalse + include Statisfy::Counter + + count every: :user_created, if_async: -> { false } + end + + class UserCounter + include Statisfy::Counter + + count every: :user_created, if_async: -> { true } + end + + User.create! + assert UserCounterFalse.value == 0 + assert UserCounter.value == 1 + end + + test "uniq_by option allows to create group of values" do + class NumberOfSteveCounter + include Statisfy::Counter + + count every: :user_created, uniq_by: -> { user.name == "Steve" } + end + + User.create!(name: "Steve") + User.create!(name: "Steve") + User.create!(name: "Bill") + + assert_equal NumberOfSteveCounter.value, 2 + end + + test "initialize_with option allows to initialize a counter when a table wasn't empty" do + 5.times { User.create! } + class UserCreated + include Statisfy::Counter + + count every: :user_created + end + + User.find_each do |user| + UserCreated.initialize_with(user) + end + + assert_equal UserCreated.value, 5 + end + + test "initialize_with can skip if validations" do + 3.times { User.create!(name: "Steve") } + 2.times { User.create!(name: "Bill") } + Redis.new.flushall + + class UserCreated + include Statisfy::Counter + + count every: :user_updated, if: -> { user.previous_changes[:name] && user.name == "Steve" } + end + assert_equal UserCreated.value, 0 + + User.where(name: "Steve").find_each do |user| + UserCreated.initialize_with(user, skip_validation: false) + end + + # Since previous_changes is missing when initializing, validation fails + assert_equal UserCreated.value, 0 + + User.where(name: "Steve").find_each do |user| + UserCreated.initialize_with(user, skip_validation: true) + end + + # Skipping validations allows to initialize the counter + assert_equal UserCreated.value, 3 + end + + test "decrement_if option allows to decrement a counter" do + paul = User.create!(name: "Paul") + jean = User.create!(name: "Jean") + marc = User.create!(name: "Marc") + + class UserCounter + include Statisfy::Counter + + count every: :user_updated, + if: -> { user.previous_changes[:name] }, + decrement_if: -> { user.name != "Steve" } + end + + paul.update!(name: "Steve") + jean.update!(name: "Steve") + marc.update!(name: "Steve") + + assert_equal UserCounter.value, 3 + + paul.update!(name: "Paul") + jean.update!(name: "Jean") + + assert_equal UserCounter.value, 1 + end + + test "aggregate option allows to aggregate instead of increment and get an average" do + class SalaryPerUser + include Statisfy::Counter + + aggregate every: :user_created, value: -> { user.salary } + end + + User.create!(salary: 2000) + User.create!(salary: 3000) + User.create!(salary: 4000) + + assert_equal 3000, SalaryPerUser.average + assert_equal 9000, SalaryPerUser.sum + end +end