Test cache without SolidCache.connects_to set

.github/workflows/main.yml

@@ -43,3 +43,5 @@ jobs:
           bin/rails db:setup
       - name: Run tests
         run: bin/rails test
+      - name: Run tests (no connects-to)
+        run: NO_CONNECTS_TO=true bin/rails test

README.md

@@ -42,12 +42,11 @@ $ gem install solid_cache
 Adding the cache to your main database:
 
 ```bash
-$ bin/rails solid_cache:install:migrations
+$ bin/rails solid_cache:install
 ```
 
-Install and run migrations:
+Then run migrations:
 ```bash
-$ bin/rails solid_cache:install:migrations
 $ bin/rails db:migrate
 ```
 
@@ -82,7 +81,7 @@ Solid cache supports these options in addition to the universal `ActiveSupport::
 - `max_age` - the maximum age of entries in the cache (default: `2.weeks.to_i`)
 - `max_entries` - the maximum number of entries allowed in the cache (default: `2.weeks.to_i`)
 - `cluster` - a Hash of options for the cache database cluster, e.g { shards: [:database1, :database2, :database3] }
-- `clusters` - and Array of Hashes for separate cache clusters (ignored if `:cluster` is set)
+- `clusters` - and Array of Hashes for multiple cache clusters (ignored if `:cluster` is set)
 - `active_record_instrumentation` - whether to instrument the cache's queries (default: `true`)
 
 For more information on cache clusters see [Sharding the cache](#sharding-the-cache)

lib/solid_cache.rb

@@ -10,7 +10,7 @@ module SolidCache
   mattr_accessor :executor, :connects_to
 
   def self.all_shard_keys
-    all_shards_config&.keys
+    all_shards_config&.keys || [ Record.default_shard ]
   end
 
   def self.all_shards_config
@@ -20,7 +20,7 @@ def self.all_shards_config
   def self.each_shard
     return to_enum(:each_shard) unless block_given?
 
-    if (shards = connects_to[:shards]&.keys)
+    if (shards = connects_to && connects_to[:shards]&.keys)
       shards.each do |shard|
         Record.connected_to(shard: shard) { yield }
       end

lib/solid_cache/shards.rb

@@ -5,13 +5,17 @@ class Shards
     def initialize(options)
       case options
       when Array, NilClass
-        @names = options || SolidCache.all_shard_keys || [SolidCache::Record.default_shard]
+        @names = options || SolidCache.all_shard_keys
         @nodes = @names.to_h { |name| [ name, name ] }
       when Hash
         @names = options.keys
         @nodes = options.invert
       end
 
+      if (unknown_shards = names - SolidCache.all_shard_keys).any?
+        raise ArgumentError, "Unknown #{"shard".pluralize(unknown_shards)}: #{unknown_shards.join(", ")}"
+      end
+
       @consistent_hash = MaglevHash.new(@nodes.keys) if sharded?
     end
 

lib/solid_cache/store/clusters.rb

@@ -58,7 +58,7 @@ def writing_keys(entries, failsafe:, failsafe_returning: nil)
             sharded_entries.map do |shard, entries|
               failsafe(failsafe, returning: failsafe_returning) do
                 cluster.with_shard(shard, async: async) do
-                  yield cluster, shard, entries
+                  yield cluster, entries
                 end
               end
             end

lib/solid_cache/store/entries.rb

@@ -41,7 +41,7 @@ def entry_write(key, payload)
         end
 
         def entry_write_multi(entries)
-          writing_keys(entries, failsafe: :write_multi_entries, failsafe_returning: false) do |cluster, shard, entries|
+          writing_keys(entries, failsafe: :write_multi_entries, failsafe_returning: false) do |cluster, entries|
             Entry.write_multi(entries)
             cluster.trim(entries.count)
             true

test/dummy/config/application.rb

@@ -24,15 +24,17 @@ class Application < Rails::Application
     # config.time_zone = "Central Time (US & Canada)"
     # config.eager_load_paths << Rails.root.join("extras")
 
-    config.solid_cache.connects_to = {
-      shards: {
-        default: { writing: :primary, reading: :primary_replica },
-        default2: { writing: :primary_shard_one, reading: :primary_shard_one_replica },
-        primary_shard_one: { writing: :primary_shard_one },
-        primary_shard_two: { writing: :primary_shard_two },
-        secondary_shard_one: { writing: :secondary_shard_one },
-        secondary_shard_two: { writing: :secondary_shard_two }
+    unless ENV["NO_CONNECTS_TO"]
+      config.solid_cache.connects_to = {
+        shards: {
+          default: { writing: :primary, reading: :primary_replica },
+          default2: { writing: :primary_shard_one, reading: :primary_shard_one_replica },
+          primary_shard_one: { writing: :primary_shard_one },
+          primary_shard_two: { writing: :primary_shard_two },
+          secondary_shard_one: { writing: :secondary_shard_one },
+          secondary_shard_two: { writing: :secondary_shard_two }
+        }
       }
-    }
+    end
   end
 end

test/test_helper.rb

@@ -18,7 +18,7 @@
 
 def lookup_store(options = {})
   store_options = { namespace: @namespace }.merge(options)
-  store_options.merge!(cluster: { shards: [:default, :default2] }) unless store_options.key?(:cluster) || store_options.key?(:clusters)
+  store_options.merge!(cluster: { shards: [:default] }) unless store_options.key?(:cluster) || store_options.key?(:clusters)
   ActiveSupport::Cache.lookup_store(:solid_cache_store, store_options)
 end
 

test/unit/cluster_test.rb

@@ -1,139 +1,141 @@
 require "test_helper"
 
 class ClusterTest < ActiveSupport::TestCase
-  setup do
-    @cache = nil
-    @namespace = "test-#{SecureRandom.hex}"
-    primary_cluster = { shards: [:primary_shard_one, :primary_shard_two] }
-    secondary_cluster = { shards: [:secondary_shard_one, :secondary_shard_two] }
-
-    @cache = lookup_store(expires_in: 60, clusters: [ primary_cluster, secondary_cluster ])
-    @primary_cache = lookup_store(expires_in: 60, cluster: primary_cluster)
-    @secondary_cache = lookup_store(expires_in: 60, cluster: secondary_cluster)
-  end
-
-  test "writes to both clusters" do
-    @cache.write("foo", 1)
-    sleep 0.1
-    assert_equal 1, @cache.read("foo")
-    assert_equal 1, @primary_cache.read("foo")
-    assert_equal 1, @secondary_cache.read("foo")
-  end
-
-  test "reads from primary cluster" do
-    @cache.write("foo", 1)
-    sleep 0.1
-    assert_equal 1, @cache.read("foo")
-
-    @secondary_cache.delete("foo")
-    assert_equal 1, @cache.read("foo")
-
-    @primary_cache.delete("foo")
-    assert_nil @cache.read("foo")
-  end
-
-  test "fetch writes to both clusters" do
-    @cache.fetch("foo") { 1 }
-    sleep 0.1
-
-    assert_equal 1, @cache.read("foo")
-    assert_equal 1, @primary_cache.read("foo")
-    assert_equal 1, @secondary_cache.read("foo")
-  end
-
-  test "fetch reads from primary clusters" do
-    @cache.fetch("foo") { 1 }
-    sleep 0.1
-    assert_equal 1, @cache.read("foo")
-
-    @primary_cache.delete("foo")
-    @cache.fetch("foo") { 2 }
-    sleep 0.1
-
-    assert_equal 2, @cache.read("foo")
-    assert_equal 2, @primary_cache.read("foo")
-    assert_equal 2, @secondary_cache.read("foo")
-
-    @secondary_cache.delete("foo")
-    assert_equal 2, @cache.fetch("foo") { 3 }
-
-    assert_equal 2, @primary_cache.read("foo")
-    assert_nil @secondary_cache.read("foo")
-  end
-
-  test "deletes from both cluster" do
-    @cache.write("foo", 1)
-    sleep 0.1
-    assert_equal 1, @cache.read("foo")
-
-    @cache.delete("foo")
-    sleep 0.1
-
-    assert_nil @cache.read("foo")
-    assert_nil @primary_cache.read("foo")
-    assert_nil @secondary_cache.read("foo")
-  end
-
-  test "multi_writes to both clusters" do
-    values = { "foo" => "bar", "egg" => "spam" }
-    @cache.write_multi(values)
-    sleep 0.1
-    assert_equal values, @cache.read_multi("foo", "egg")
-    assert_equal values, @primary_cache.read_multi("foo", "egg")
-    assert_equal values, @secondary_cache.read_multi("foo", "egg")
-  end
-
-  test "delete_matched deletes from both caches" do
-    values = { "foo" => "bar", "baz" => "zab", "bab" => "dab" }
-    @cache.write_multi(values)
-    sleep 0.1
-
-    @cache.delete_matched("ba%")
-    sleep 0.1
-
-    assert_equal({ "foo" => "bar" }, @cache.read_multi(*values.keys))
-    assert_equal({ "foo" => "bar" }, @primary_cache.read_multi(*values.keys))
-    assert_equal({ "foo" => "bar" }, @secondary_cache.read_multi(*values.keys))
-  end
-
-  test "increment and decrement hit both clusters" do
-    @cache.write("foo", 1, raw: true)
-    sleep 0.1
-
-    assert_equal 1, @cache.read("foo", raw: true).to_i
-    assert_equal 1, @primary_cache.read("foo", raw: true).to_i
-    assert_equal 1, @secondary_cache.read("foo", raw: true).to_i
-
-    @cache.increment("foo")
-    sleep 0.1
-
-    assert_equal 2, @cache.read("foo", raw: true).to_i
-    assert_equal 2, @primary_cache.read("foo", raw: true).to_i
-    assert_equal 2, @secondary_cache.read("foo", raw: true).to_i
-
-    @secondary_cache.write("foo", 4, raw: true)
-
-    @cache.decrement("foo")
-    sleep 0.1
-
-    assert_equal 1, @cache.read("foo", raw: true).to_i
-    assert_equal 1, @primary_cache.read("foo", raw: true).to_i
-    assert_equal 3, @secondary_cache.read("foo", raw: true).to_i
-  end
-
-  test "cache with node names" do
-    @namespace = "test-#{SecureRandom.hex}"
-    primary_cluster = { shards: { primary_shard_one: :node1, primary_shard_two: :node2 } }
-    secondary_cluster = { shards: { primary_shard_one: :node3, primary_shard_two: :node4 } }
-
-    @cache = lookup_store(expires_in: 60, clusters: [ primary_cluster, secondary_cluster ])
-    @primary_cache = lookup_store(expires_in: 60, cluster: primary_cluster)
-    @secondary_cache = lookup_store(expires_in: 60, cluster: secondary_cluster)
-
-    @cache.write("foo", 1)
-    sleep 0.1
-    assert_equal 1, @cache.read("foo")
-    assert_equal 1, @primary_cache.read("foo")
-    assert_equal 1, @secondary_cache.read("foo")
+  unless ENV["NO_CONNECTS_TO"]
+    setup do
+      @cache = nil
+      @namespace = "test-#{SecureRandom.hex}"
+      primary_cluster = { shards: [:primary_shard_one, :primary_shard_two] }
+      secondary_cluster = { shards: [:secondary_shard_one, :secondary_shard_two] }
+
+      @cache = lookup_store(expires_in: 60, clusters: [ primary_cluster, secondary_cluster ])
+      @primary_cache = lookup_store(expires_in: 60, cluster: primary_cluster)
+      @secondary_cache = lookup_store(expires_in: 60, cluster: secondary_cluster)
+    end
+
+    test "writes to both clusters" do
+      @cache.write("foo", 1)
+      sleep 0.1
+      assert_equal 1, @cache.read("foo")
+      assert_equal 1, @primary_cache.read("foo")
+      assert_equal 1, @secondary_cache.read("foo")
+    end
+
+    test "reads from primary cluster" do
+      @cache.write("foo", 1)
+      sleep 0.1
+      assert_equal 1, @cache.read("foo")
+
+      @secondary_cache.delete("foo")
+      assert_equal 1, @cache.read("foo")
+
+      @primary_cache.delete("foo")
+      assert_nil @cache.read("foo")
+    end
+
+    test "fetch writes to both clusters" do
+      @cache.fetch("foo") { 1 }
+      sleep 0.1
+
+      assert_equal 1, @cache.read("foo")
+      assert_equal 1, @primary_cache.read("foo")
+      assert_equal 1, @secondary_cache.read("foo")
+    end
+
+    test "fetch reads from primary clusters" do
+      @cache.fetch("foo") { 1 }
+      sleep 0.1
+      assert_equal 1, @cache.read("foo")
+
+      @primary_cache.delete("foo")
+      @cache.fetch("foo") { 2 }
+      sleep 0.1
+
+      assert_equal 2, @cache.read("foo")
+      assert_equal 2, @primary_cache.read("foo")
+      assert_equal 2, @secondary_cache.read("foo")
+
+      @secondary_cache.delete("foo")
+      assert_equal 2, @cache.fetch("foo") { 3 }
+
+      assert_equal 2, @primary_cache.read("foo")
+      assert_nil @secondary_cache.read("foo")
+    end
+
+    test "deletes from both cluster" do
+      @cache.write("foo", 1)
+      sleep 0.1
+      assert_equal 1, @cache.read("foo")
+
+      @cache.delete("foo")
+      sleep 0.1
+
+      assert_nil @cache.read("foo")
+      assert_nil @primary_cache.read("foo")
+      assert_nil @secondary_cache.read("foo")
+    end
+
+    test "multi_writes to both clusters" do
+      values = { "foo" => "bar", "egg" => "spam" }
+      @cache.write_multi(values)
+      sleep 0.1
+      assert_equal values, @cache.read_multi("foo", "egg")
+      assert_equal values, @primary_cache.read_multi("foo", "egg")
+      assert_equal values, @secondary_cache.read_multi("foo", "egg")
+    end
+
+    test "delete_matched deletes from both caches" do
+      values = { "foo" => "bar", "baz" => "zab", "bab" => "dab" }
+      @cache.write_multi(values)
+      sleep 0.1
+
+      @cache.delete_matched("ba%")
+      sleep 0.1
+
+      assert_equal({ "foo" => "bar" }, @cache.read_multi(*values.keys))
+      assert_equal({ "foo" => "bar" }, @primary_cache.read_multi(*values.keys))
+      assert_equal({ "foo" => "bar" }, @secondary_cache.read_multi(*values.keys))
+    end
+
+    test "increment and decrement hit both clusters" do
+      @cache.write("foo", 1, raw: true)
+      sleep 0.1
+
+      assert_equal 1, @cache.read("foo", raw: true).to_i
+      assert_equal 1, @primary_cache.read("foo", raw: true).to_i
+      assert_equal 1, @secondary_cache.read("foo", raw: true).to_i
+
+      @cache.increment("foo")
+      sleep 0.1
+
+      assert_equal 2, @cache.read("foo", raw: true).to_i
+      assert_equal 2, @primary_cache.read("foo", raw: true).to_i
+      assert_equal 2, @secondary_cache.read("foo", raw: true).to_i
+
+      @secondary_cache.write("foo", 4, raw: true)
+
+      @cache.decrement("foo")
+      sleep 0.1
+
+      assert_equal 1, @cache.read("foo", raw: true).to_i
+      assert_equal 1, @primary_cache.read("foo", raw: true).to_i
+      assert_equal 3, @secondary_cache.read("foo", raw: true).to_i
+    end
+
+    test "cache with node names" do
+      @namespace = "test-#{SecureRandom.hex}"
+      primary_cluster = { shards: { primary_shard_one: :node1, primary_shard_two: :node2 } }
+      secondary_cluster = { shards: { primary_shard_one: :node3, primary_shard_two: :node4 } }
+
+      @cache = lookup_store(expires_in: 60, clusters: [ primary_cluster, secondary_cluster ])
+      @primary_cache = lookup_store(expires_in: 60, cluster: primary_cluster)
+      @secondary_cache = lookup_store(expires_in: 60, cluster: secondary_cluster)
+
+      @cache.write("foo", 1)
+      sleep 0.1
+      assert_equal 1, @cache.read("foo")
+      assert_equal 1, @primary_cache.read("foo")
+      assert_equal 1, @secondary_cache.read("foo")
+    end
   end
 end