expect_query 0.1.5 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d3b8b4ed6d2b74521cc8ba8b8c3d916cccb41270c4c41823bc24ece67d51e2ba
-  data.tar.gz: 9dad000453c5308bde228f74313820d502efcc8ddab0ea4d64012d1c2cfb8a9d
+  metadata.gz: 53cd97190ff208c5ddf0f7ea4b2defad56c2651766e25b2faa70e2d495c30774
+  data.tar.gz: da83d3a86398c231e636a0b7ba7938ed16f690a43a9085d7fc5fd6857ed6d34f
 SHA512:
-  metadata.gz: 74308e0df458e741d4cb8af5b079b164858ab846bfca7d4253fb4c1b5018c8f5aa254b1085d23ec92f44a06fc019b75d20e75837f2df52af7e688d95f9955f5d
-  data.tar.gz: bb3009cbc2d35194b6dc4e30aa1807ed70b313d56c8767303eec51e44757224e767f88d171824ad244a2ffb859ec2d3f86c6617ec0d2ce2ca6b739384ec4a94b
+  metadata.gz: 60cb5e8d7672d3124c2a21e4f22eebbe9b29aa3e0d214cb921b568af3f21b5101716b3af6773056734a44c97331b7a60163b579a8f0dfbc75d92e43167753b31
+  data.tar.gz: aeb1ba386cc83d8bb8ace523657ec557fef0a598c4f579631262fb3eb9a347a927cdeebc09d22c3677d49bd900d69c5845901697ac5a655009fe4e2f601e081c

data/README.md

@@ -1,6 +1,6 @@
 # ExpectQuery
 
-`expect_query` provides Rails 8.0+ compatible assertions and matchers for counting SQL queries and Cache operations. It supports both RSpec and Minitest.
+`expect_query` provides Rails 8.0+ compatible assertions and matchers for counting SQL queries and Cache operations. It supports both RSpec and Minitest, offering powerful tools to prevent N+1 queries and ensure efficient caching.
 
 ## Installation
 
@@ -22,55 +22,79 @@ require "expect_query/rspec"
 
 #### SQL Assertions
 
+Verify the number of SQL queries executed.
+
 ```ruby
+# Exact count
 expect { 
   User.first 
 }.to make_sql_queries(1)
 
+# At most (useful for reducing N+1 without being brittle)
+expect {
+  User.all.each(&:profile)
+}.to make_sql_queries(at_most: 3)
+
+# Filter by regex matching SQL
 expect { 
   User.create(name: "Foo") 
 }.to make_sql_queries(1, matching: /INSERT/)
-
-expect {
-  # ...
-}.to make_sql_queries(at_most: 3)
 ```
 
 #### Cache Assertions
 
+Verify cache operations (read, write, fetch, etc.).
+
 ```ruby
+# Count specific operations
 expect {
   Rails.cache.read("foo")
   Rails.cache.write("bar", 1)
 }.to perform_cache_operations(read: 1, write: 1)
 
+# Count total operations
 expect {
   Rails.cache.fetch("foo") { 1 }
-}.to perform_cache_operations(total: 2) # read + write (if miss)
+}.to perform_cache_operations(total: 2) # 1 read (miss) + 1 write
+
+# Filter by key matching regex
+expect {
+  Rails.cache.read("user:1")
+  Rails.cache.read("post:1")
+}.to perform_cache_operations(read: 2, matching: /user|post/)
+```
+
+#### Chaining Matchers
+
+You can verify both SQL and Cache operations in a single block using RSpec's compound matchers.
+
+```ruby
+expect {
+  User.create(name: "Alice")
+  Rails.cache.write("user:alice", "data")
+}.to make_sql_queries(1).and perform_cache_operations(write: 1)
 ```
 
 ### Multiple Cache Stores
 
-By default, assertions use `Rails.cache` (if available). You can specify a different store or multiple stores using `store` or `stores` options.
+By default, assertions use `Rails.cache`. You can specify a different store or multiple stores using `store` or `stores` options.
 
 ```ruby
-# RSpec
+# Check specific store
 expect {
   my_cache.write("foo", 1)
 }.to perform_cache_operations(write: 1, store: my_cache)
 
+# Check multiple stores
 expect {
   cache1.write("a", 1)
   cache2.write("b", 1)
 }.to perform_cache_operations(total: 2, stores: [cache1, cache2])
 ```
 
-```ruby
-# Minitest
-assert_cache_operations(write: 1, store: my_cache) do
-  my_cache.write("foo", 1)
-end
-```
+### Minitest
+
+Add this to your `test_helper.rb`:
 
 ```ruby
 require "expect_query/minitest"
@@ -79,18 +103,60 @@ require "expect_query/minitest"
 #### SQL Assertions
 
 ```ruby
+# Exact count
 assert_sql_queries(1) do
   User.first
 end
+
+# At most
+assert_sql_queries(at_most: 3) do
+  User.all.map(&:name)
+end
+
+# Regex matching
+assert_sql_queries(1, matching: /INSERT/) do
+  User.create(name: "Foo")
+end
 ```
 
 #### Cache Assertions
 
 ```ruby
+# Specific operations
 assert_cache_operations(read: 1, write: 1) do
   Rails.cache.read("foo")
   Rails.cache.write("bar", 1)
 end
+
+# Total operations
+assert_cache_operations(total: 2) do
+  Rails.cache.fetch("foo") { 1 }
+end
+
+# Specific store
+assert_cache_operations(write: 1, store: my_cache) do
+  my_cache.write("foo", 1)
+end
+```
+
+#### Combined Assertions (IO Operations)
+
+Use `assert_io_operations` to verify both SQL and Cache operations in a single block.
+
+```ruby
+assert_io_operations(sql: { count: 1 }, cache: { write: 1 }) do
+  User.create(name: "Alice")
+  Rails.cache.write("user:alice", "data")
+end
+
+# With options
+assert_io_operations(
+  sql: { count: 1, matching: /INSERT/ }, 
+  cache: { read: 1, matching: /user:/ }
+) do
+  User.create(name: "Bob")
+  Rails.cache.read("user:bob")
+end
 ```
 
 ## Failure Messages
@@ -125,4 +191,3 @@ bundle exec rake
 ```
 
 This runs both RSpec and Minitest suites.
-

data/lib/expect_query/minitest.rb

@@ -66,6 +66,36 @@ module ExpectQuery
         assert_equal expected, actual, "Expected #{expected} #{op} cache operations, but got #{actual}#{debug_info}"
       end
     end
+
+    def assert_io_operations(sql: nil, cache: nil, &block)
+      if sql
+        sql_args = sql.dup
+        count = sql_args.delete(:count)
+        matching = sql_args.delete(:matching)
+        at_most = sql_args.delete(:at_most)
+        
+        # If unknown keys remain in sql_args, we could warn, but for now we verify strictness if possible?
+        # assert_sql_queries doesn't take **options, so we can't pass them.
+        
+        inner_block = if cache
+          proc { assert_io_operations(cache: cache, &block) }
+        else
+          block
+        end
+        
+        assert_sql_queries(count, matching: matching, at_most: at_most, &inner_block)
+      elsif cache
+        cache_args = cache.dup
+        count = cache_args.delete(:count)
+        matching = cache_args.delete(:matching)
+        store = cache_args.delete(:store)
+        stores = cache_args.delete(:stores)
+        
+        assert_cache_operations(count, matching: matching, store: store, stores: stores, **cache_args, &block)
+      else
+        block.call
+      end
+    end
   end
 end
 

data/lib/expect_query/rspec.rb

@@ -25,22 +25,22 @@ module ExpectQuery
         true
       end
 
-      def matches?(block)
-        @counter = ExpectQuery::SqlCounter.new(matching: @matching)
-        ActiveSupport::Notifications.subscribed(@counter, "sql.active_record") do
-          block.call
-        end
-        
-        @actual = @counter.count
-        
-        if @at_most
-          @actual <= @at_most
-        elsif @expected
-          @actual == @expected
-        else
-          @actual > 0 # generic "makes queries"
-        end
+    def matches?(block)
+      @counter = ExpectQuery::SqlCounter.new(matching: @matching)
+      ActiveSupport::Notifications.subscribed(@counter, "sql.active_record") do
+        block.call
       end
+      
+      @actual = @counter.count
+      
+      if @at_most
+        @actual <= @at_most
+      elsif @expected
+        @actual == @expected
+      else
+        @actual > 0 # generic "makes queries"
+      end
+    end
 
       def failure_message
         msg = "expected to make "
@@ -86,12 +86,6 @@ module ExpectQuery
           store_ids << store.object_id
         end
 
-        # If no stores are defined (e.g. no Rails.cache and no store passed), we can't strict filter by ID.
-        # But we probably should pass empty array if we intended to track but found nothing? 
-        # Or if store_ids is empty, maybe we track ALL?
-        # User said: "By default use Rails.cache". If Rails.cache is missing, maybe we should warn or track nothing?
-        # Let's pass nil if we want to track ALL, but if we defaulted to Rails.cache and it's there, we pass it.
-        # If user explicitly passed empty list?
         pass_ids = store_ids.empty? ? nil : store_ids
 
         @counter = ExpectQuery::CacheCounter.new(matching: @matching, store_ids: pass_ids)

data/lib/expect_query/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ExpectQuery
-  VERSION = "0.1.5"
+  VERSION = "0.1.6"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: expect_query
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.6
 platform: ruby
 authors:
 - Jade Ornelas