activerecord_views 0.0.17 → 0.1.1

data/lib/active_record_views/railtie.rb

@@ -2,15 +2,25 @@ module ActiveRecordViews
   class Railtie < ::Rails::Railtie
     initializer 'active_record_views' do |app|
       ActiveSupport.on_load :active_record do
-        ActiveRecordViews.sql_load_path << Rails.root + 'app/models'
+        ActiveRecordViews.sql_load_path += Rails.application.config.paths['app/models'].to_a
         ActiveRecordViews.init!
+        ActiveRecordViews::Extension.create_enabled = !Rails.env.production?
       end
 
-      ActiveSupport.on_load :action_controller do
-        unless app.config.cache_classes
-          ActionDispatch::Callbacks.before do
+      unless app.config.cache_classes
+        if app.respond_to?(:reloader)
+          app.reloader.before_class_unload do
             ActiveRecordViews.reload_stale_views!
           end
+          app.executor.to_run do
+            ActiveRecordViews.reload_stale_views!
+          end
+        else
+          ActiveSupport.on_load :action_controller do
+            ActionDispatch::Callbacks.before do
+              ActiveRecordViews.reload_stale_views!
+            end
+          end
         end
       end
     end

data/lib/active_record_views/registered_view.rb

@@ -1,6 +1,6 @@
 module ActiveRecordViews
   class RegisteredView
-    attr_reader :sql_path
+    attr_reader :model_class_name, :sql_path
 
     def initialize(model_class, sql_path)
       @model_class_name = model_class.name
@@ -16,9 +16,14 @@ module ActiveRecordViews
       sql_timestamp != @cached_sql_timestamp
     end
 
+    def dead?
+      !File.exist?(sql_path)
+    end
+
     def reload!
       if File.exist? sql_path
-        ActiveRecordViews.create_view model_class.connection, model_class.table_name, model_class.name, ActiveRecordViews.read_sql_file(sql_path), model_class.view_options
+        ActiveRecordViews.create_view model_class.connection, model_class.table_name, model_class.name, ActiveRecordViews.read_sql_file(model_class, sql_path), model_class.view_options
+        model_class.reset_column_information
       else
         ActiveRecordViews.drop_view model_class.connection, model_class.table_name
       end

data/lib/active_record_views/version.rb

@@ -1,3 +1,3 @@
 module ActiveRecordViews
-  VERSION = '0.0.17'
+  VERSION = '0.1.1'
 end

data/lib/tasks/active_record_views.rake

@@ -1,24 +1,77 @@
-Rake::Task['db:structure:dump'].enhance do
-  if ActiveRecord::Base.connection.table_exists?('active_record_views')
-    filename = ENV['DB_STRUCTURE'] || File.join(Rails.root, "db", "structure.sql")
-
-    if defined? ActiveRecord::Tasks::DatabaseTasks
-      tasks = ActiveRecord::Tasks::DatabaseTasks
-      config = tasks.current_config
-      tasks.send(:class_for_adapter, config.fetch('adapter')).new(config)
-      pg_tasks = tasks.send(:class_for_adapter, config.fetch('adapter')).new(config)
-      pg_tasks.send(:set_psql_env)
+Rake::Task['db:migrate'].enhance do
+  unless ActiveRecordViews::Extension.create_enabled
+    Rails.application.eager_load!
+    ActiveRecordViews::Extension.process_create_queue!
+    ActiveRecordViews.drop_unregistered_views!
+  end
+end
+
+schema_rake_task = Gem::Version.new(Rails.version) >= Gem::Version.new("6.1") ? 'db:schema:dump' : 'db:structure:dump'
+
+Rake::Task[schema_rake_task].enhance do
+  table_exists = if Rails::VERSION::MAJOR >= 5
+    ActiveRecord::Base.connection.data_source_exists?('active_record_views')
+  else
+    ActiveRecord::Base.connection.table_exists?('active_record_views')
+  end
+
+  if schema_rake_task == 'db:structure:dump'
+    ActiveRecord::Base.schema_format = :sql
+  end
+
+  if table_exists && ActiveRecord::Base.schema_format == :sql
+    tasks = ActiveRecord::Tasks::DatabaseTasks
+
+    filename = case
+    when tasks.respond_to?(:dump_filename)
+      tasks.dump_filename('primary')
     else
-      config = current_config
-      set_psql_env(config)
+      tasks.schema_file
     end
 
-    require 'shellwords'
-    system("pg_dump --data-only --table=active_record_views #{Shellwords.escape config['database']} >> #{Shellwords.escape filename}")
-    raise 'active_record_views metadata dump failed' unless $?.success?
+    config = if ActiveRecord::Base.configurations.respond_to?(:configs_for)
+      if Rails.version.start_with?('6.0.')
+        ActiveRecord::Base.configurations.configs_for(env_name: Rails.env, spec_name: 'primary').config
+      else
+        ActiveRecord::Base.configurations.configs_for(env_name: Rails.env, name: 'primary')
+      end
+    else
+      tasks.current_config
+    end
+    adapter = if config.respond_to?(:adapter)
+      config.adapter
+    else
+      config.fetch('adapter')
+    end
+    database = if config.respond_to?(:database)
+      config.database
+    else
+      config.fetch('database')
+    end
+
+    pg_tasks = tasks.send(:class_for_adapter, adapter).new(config)
+    pg_tasks.send(:set_psql_env)
+
+    begin
+      active_record_views_dump = Tempfile.open("active_record_views_dump.sql")
+      require 'shellwords'
+      system("pg_dump --data-only --no-owner --table=active_record_views #{Shellwords.escape database} >> #{Shellwords.escape active_record_views_dump.path}")
+      raise 'active_record_views metadata dump failed' unless $?.success?
+
+      if Gem::Version.new(Rails.version) >= Gem::Version.new("5.1")
+        pg_tasks.send(:remove_sql_header_comments, active_record_views_dump.path)
+      end
+
+      File.open filename, 'a' do |io|
+        # Seek to the end to ensure we don't overwrite the existing content
+        io.seek(0, IO::SEEK_END)
+        IO.copy_stream active_record_views_dump, io
 
-    File.open filename, 'a' do |io|
-      io.puts 'UPDATE public.active_record_views SET refreshed_at = NULL WHERE refreshed_at IS NOT NULL;'
+        io.puts 'UPDATE public.active_record_views SET refreshed_at = NULL WHERE refreshed_at IS NOT NULL;'
+      end
+    ensure
+      active_record_views_dump.close
+      active_record_views_dump.unlink
     end
   end
 end

data/spec/active_record_views_checksum_cache_spec.rb

@@ -4,13 +4,21 @@ describe ActiveRecordViews::ChecksumCache do
   let(:connection) { ActiveRecord::Base.connection }
 
   describe 'initialisation' do
+    def metadata_table_exists?
+      if Rails::VERSION::MAJOR >= 5
+        connection.data_source_exists?('active_record_views')
+      else
+        connection.table_exists?('active_record_views')
+      end
+    end
+
     context 'no existing table' do
       it 'creates the table' do
         expect(ActiveRecord::Base.connection).to receive(:execute).with(/\ACREATE TABLE active_record_views/).once.and_call_original
 
-        expect(connection.table_exists?('active_record_views')).to eq false
+        expect(metadata_table_exists?).to eq false
         ActiveRecordViews::ChecksumCache.new(connection)
-        expect(connection.table_exists?('active_record_views')).to eq true
+        expect(metadata_table_exists?).to eq true
 
         expect(connection.column_exists?('active_record_views', 'class_name')).to eq true
         expect(connection.column_exists?('active_record_views', 'options')).to eq true
@@ -20,7 +28,7 @@ describe ActiveRecordViews::ChecksumCache do
     context 'existing table with current structure' do
       before do
         ActiveRecordViews::ChecksumCache.new(connection)
-        expect(connection.table_exists?('active_record_views')).to eq true
+        expect(metadata_table_exists?).to eq true
       end
 
       it 'does not recreate the table' do
@@ -41,21 +49,22 @@ describe ActiveRecordViews::ChecksumCache do
       end
 
       it 'drops existing managed views recreates the table' do
-        expect(ActiveRecord::Base.connection).to receive(:execute).with(/\ABEGIN\z/).once.and_call_original
-        if Rails::VERSION::MAJOR < 4
-          expect(ActiveRecord::Base.connection).to receive(:execute).with('SELECT name FROM active_record_views;', nil).once.and_call_original
-        end
-        expect(ActiveRecord::Base.connection).to receive(:execute).with(/\ADROP VIEW IF EXISTS test_view CASCADE;\z/).once.and_call_original
-        expect(ActiveRecord::Base.connection).to receive(:execute).with(/\ADROP TABLE active_record_views;\z/).once.and_call_original
-        expect(ActiveRecord::Base.connection).to receive(:execute).with(/\ACREATE TABLE active_record_views/).once.and_call_original
-        expect(ActiveRecord::Base.connection).to receive(:execute).with(/\ACOMMIT\z/).once.and_call_original
-
         expect(connection.column_exists?('active_record_views', 'class_name')).to eq false
         expect(ActiveRecordViews.view_exists?(connection, 'test_view')).to eq true
         expect(ActiveRecordViews.view_exists?(connection, 'other_view')).to eq true
 
+        sql_statements.clear
+
         ActiveRecordViews::ChecksumCache.new(connection)
 
+        expect(sql_statements.grep_v(/^\s*SELECT/)).to match [
+          'BEGIN',
+          'DROP VIEW IF EXISTS test_view CASCADE;',
+          'DROP TABLE active_record_views;',
+          /^CREATE TABLE active_record_views/,
+          'COMMIT',
+        ]
+
         expect(connection.column_exists?('active_record_views', 'class_name')).to eq true
         expect(ActiveRecordViews.view_exists?(connection, 'test_view')).to eq false
         expect(ActiveRecordViews.view_exists?(connection, 'other_view')).to eq true

data/spec/active_record_views_extension_spec.rb

@@ -2,6 +2,19 @@ require 'spec_helper'
 
 describe ActiveRecordViews::Extension do
   describe '.is_view' do
+    def registered_model_class_names
+      ActiveRecordViews.registered_views.map(&:model_class_name)
+    end
+
+    def view_exists?(name)
+      connection = ActiveRecord::Base.connection
+      if connection.respond_to?(:view_exists?)
+        connection.view_exists?(name)
+      else
+        connection.table_exists?(name)
+      end
+    end
+
     it 'creates database views from heredocs' do
       expect(ActiveRecordViews).to receive(:create_view).once.and_call_original
       expect(HeredocTestModel.first.name).to eq 'Here document'
@@ -19,43 +32,50 @@ describe ActiveRecordViews::Extension do
 
     it 'creates database views from external ERB files' do
       expect(ActiveRecordViews).to receive(:create_view).once.and_call_original
-      expect(ErbTestModel.first.name).to eq 'ERB file'
+      expect(ErbTestModel.first.name).to eq 'ERB method file'
     end
 
     it 'errors if external SQL file is missing' do
       expect {
-        MissingFileTestModel
+        class MissingFileTestModel < ActiveRecord::Base
+          is_view
+        end
       }.to raise_error RuntimeError, /could not find missing_file_test_model.sql/
     end
 
     it 'reloads the database view when external SQL file is modified' do
-      %w[foo bar baz].each do |sql|
-        expect(ActiveRecordViews).to receive(:create_view).with(
-          anything,
-          'modified_file_test_models',
-          'ModifiedFileTestModel',
-          sql,
-          {}
-        ).once.ordered
-      end
-
-      with_temp_sql_dir do |temp_dir|
-        sql_file = File.join(temp_dir, 'modified_file_test_model.sql')
-        update_file sql_file, 'foo'
+      sql_file = File.join(TEST_TEMP_MODEL_DIR, 'modified_file_test_model.sql')
+      update_file sql_file, "SELECT 'foo'::text AS test"
 
+      expect {
+        expect(ActiveRecordViews).to receive(:create_view).once.and_call_original
         class ModifiedFileTestModel < ActiveRecord::Base
           is_view
         end
+      }.to change { begin; ModifiedFileTestModel.take!.test; rescue NameError; end }.from(nil).to('foo')
+        .and change { registered_model_class_names.include?('ModifiedFileTestModel') }.from(false).to(true)
 
-        update_file sql_file, 'bar'
+      expect {
+        update_file sql_file, "SELECT 'bar'::text AS test, 42::integer AS test2"
+      }.to_not change { ModifiedFileTestModel.take!.test }
 
+      expect {
+        expect(ActiveRecordViews).to receive(:create_view).once.and_call_original
         test_request
         test_request # second request does not `create_view` again
+      }.to change { ModifiedFileTestModel.take!.test }.to('bar')
+        .and change { ModifiedFileTestModel.column_names }.from(%w[test]).to(%w[test test2])
 
-        update_file sql_file, 'baz'
+      expect {
+        update_file sql_file, "SELECT 'baz'::text AS test"
+      }.to_not change { ModifiedFileTestModel.take!.test }
 
+      expect {
+        expect(ActiveRecordViews).to receive(:create_view).once.and_call_original
         test_request
-      end
+      }.to change { ModifiedFileTestModel.take!.test }.to('baz')
+
+      File.unlink sql_file
       test_request # trigger cleanup
     end
 
@@ -70,40 +90,53 @@ describe ActiveRecordViews::Extension do
         ).once.ordered
       end
 
-      with_temp_sql_dir do |temp_dir|
-        sql_file = File.join(temp_dir, 'modified_erb_file_test_model.sql.erb')
-        update_file sql_file, 'foo <%= 2*3*7 %>'
+      sql_file = File.join(TEST_TEMP_MODEL_DIR, 'modified_erb_file_test_model.sql.erb')
+      update_file sql_file, 'foo <%= test_erb_method %>'
 
-        class ModifiedErbFileTestModel < ActiveRecord::Base
-          is_view
+      class ModifiedErbFileTestModel < ActiveRecord::Base
+        def self.test_erb_method
+          2 * 3 * 7
         end
 
-        update_file sql_file, 'bar <%= 2*3*7 %>'
-        test_request
+        is_view
       end
+
+      update_file sql_file, 'bar <%= test_erb_method %>'
+      test_request
+
+      File.unlink sql_file
       test_request # trigger cleanup
     end
 
     it 'drops the view if the external SQL file is deleted' do
-      with_temp_sql_dir do |temp_dir|
-        sql_file = File.join(temp_dir, 'deleted_file_test_model.sql')
-        File.write sql_file, "SELECT 1 AS id, 'delete test'::text AS name"
+      sql_file = File.join(TEST_TEMP_MODEL_DIR, 'deleted_file_test_model.sql')
+      File.write sql_file, "SELECT 1 AS id, 'delete test'::text AS name"
 
+      rb_file = 'spec/internal/app/models_temp/deleted_file_test_model.rb'
+      File.write rb_file, <<~RB
         class DeletedFileTestModel < ActiveRecord::Base
           is_view
         end
+      RB
 
+      with_reloader do
         expect(DeletedFileTestModel.first.name).to eq 'delete test'
+      end
 
-        File.unlink sql_file
+      File.unlink sql_file
+      File.unlink rb_file
 
-        expect(ActiveRecord::Base.connection).to receive(:execute).with(/\ADROP/).once.and_call_original
+      expect(ActiveRecord::Base.connection).to receive(:execute).with(/\ADROP/).once.and_call_original
+      expect {
         test_request
-        test_request # second request does not `drop_view` again
+      }.to change { registered_model_class_names.include?('DeletedFileTestModel') }.from(true).to(false)
+        .and change { view_exists?('deleted_file_test_models') }.from(true).to(false)
+      test_request # second request does not `drop_view` again
 
+      if Rails::VERSION::MAJOR >= 5
         expect {
           DeletedFileTestModel.first.name
-        }.to raise_error ActiveRecord::StatementInvalid, /relation "deleted_file_test_models" does not exist/
+        }.to raise_error NameError, 'uninitialized constant DeletedFileTestModel'
       end
     end
 
@@ -161,37 +194,34 @@ describe ActiveRecordViews::Extension do
     end
 
     it 'creates/refreshes/drops materialized views' do
-      with_temp_sql_dir do |temp_dir|
-        sql_file = File.join(temp_dir, 'materialized_view_test_model.sql')
-        File.write sql_file, 'SELECT 123 AS id;'
+      sql_file = File.join(TEST_TEMP_MODEL_DIR, 'materialized_view_test_model.sql')
+      File.write sql_file, 'SELECT 123 AS id;'
 
-        class MaterializedViewTestModel < ActiveRecord::Base
-          is_view materialized: true
-        end
+      class MaterializedViewTestModel < ActiveRecord::Base
+        is_view materialized: true
+      end
 
-        expect {
-          MaterializedViewTestModel.first!
-        }.to raise_error ActiveRecord::StatementInvalid, /materialized view "materialized_view_test_models" has not been populated/
+      expect {
+        MaterializedViewTestModel.first!
+      }.to raise_error ActiveRecord::StatementInvalid, /materialized view "materialized_view_test_models" has not been populated/
 
-        expect(MaterializedViewTestModel.view_populated?).to eq false
-        expect(MaterializedViewTestModel.refreshed_at).to eq nil
+      expect(MaterializedViewTestModel.view_populated?).to eq false
+      expect(MaterializedViewTestModel.refreshed_at).to eq nil
 
-        MaterializedViewTestModel.refresh_view!
+      MaterializedViewTestModel.refresh_view!
 
-        expect(MaterializedViewTestModel.view_populated?).to eq true
-        expect(MaterializedViewTestModel.refreshed_at).to be_a ActiveSupport::TimeWithZone
-        expect(MaterializedViewTestModel.refreshed_at.zone).to eq 'UTC'
-        expect(MaterializedViewTestModel.refreshed_at).to be_within(1.second).of Time.now
+      expect(MaterializedViewTestModel.view_populated?).to eq true
+      expect(MaterializedViewTestModel.refreshed_at).to be_a Time
+      expect(MaterializedViewTestModel.refreshed_at.zone).to eq 'UTC'
+      expect(MaterializedViewTestModel.refreshed_at).to be_within(1.second).of Time.now
 
-        expect(MaterializedViewTestModel.first!.id).to eq 123
+      expect(MaterializedViewTestModel.first!.id).to eq 123
 
-        File.unlink sql_file
-        test_request
+      File.unlink sql_file
 
-        expect {
-          MaterializedViewTestModel.first!
-        }.to raise_error ActiveRecord::StatementInvalid, /relation "materialized_view_test_models" does not exist/
-      end
+      expect {
+        test_request
+      }.to change { view_exists?('materialized_view_test_models') }.from(true).to(false)
     end
 
     it 'raises an error for `view_populated?` if view is not materialized' do
@@ -217,7 +247,7 @@ describe ActiveRecordViews::Extension do
         is_view "SELECT * FROM #{EnsurePopulatedBar.table_name}", dependencies: [EnsurePopulatedBar]
       end
 
-      expect(ActiveRecord::Base.connection).to receive(:execute).with(/^REFRESH MATERIALIZED VIEW/).once.and_call_original
+      expect(ActiveRecord::Base.connection).to receive(:execute).with('REFRESH MATERIALIZED VIEW "ensure_populated_foos";').once.and_call_original
       allow(ActiveRecord::Base.connection).to receive(:execute).and_call_original
 
       expect(EnsurePopulatedFoo.view_populated?).to eq false
@@ -227,6 +257,23 @@ describe ActiveRecordViews::Extension do
       expect(EnsurePopulatedFoo.view_populated?).to eq true
     end
 
+    it 'invalidates ActiveRecord query cache after populating' do
+      class EnsurePopulatedCache < ActiveRecord::Base
+        is_view 'SELECT 1 AS id;', materialized: true
+      end
+
+      expect(ActiveRecord::Base.connection).to receive(:execute).with('REFRESH MATERIALIZED VIEW "ensure_populated_caches";').once.and_call_original
+      allow(ActiveRecord::Base.connection).to receive(:execute).and_call_original
+
+      ActiveRecord::Base.connection.cache do
+        expect(EnsurePopulatedCache.view_populated?).to eq false
+        EnsurePopulatedCache.ensure_populated!
+        expect(EnsurePopulatedCache.view_populated?).to eq true
+        EnsurePopulatedCache.ensure_populated!
+        expect(EnsurePopulatedCache.view_populated?).to eq true
+      end
+    end
+
     it 'supports refreshing materialized views concurrently' do
       class MaterializedViewRefreshTestModel < ActiveRecord::Base
         is_view 'SELECT 1 AS id;', materialized: true
@@ -234,23 +281,50 @@ describe ActiveRecordViews::Extension do
       class MaterializedViewConcurrentRefreshTestModel < ActiveRecord::Base
         is_view 'SELECT 1 AS id;', materialized: true, unique_columns: [:id]
       end
+      MaterializedViewRefreshTestModel.refresh_view!
       MaterializedViewConcurrentRefreshTestModel.refresh_view!
 
-      [
+      sql_statements.clear
+
+      MaterializedViewRefreshTestModel.refresh_view!
+      MaterializedViewRefreshTestModel.refresh_view! concurrent: false
+      expect {
+        MaterializedViewRefreshTestModel.refresh_view! concurrent: true
+      }.to raise_error ActiveRecord::StatementInvalid, /^PG::ObjectNotInPrerequisiteState: ERROR: +cannot refresh/
+      MaterializedViewConcurrentRefreshTestModel.refresh_view!
+      MaterializedViewConcurrentRefreshTestModel.refresh_view! concurrent: false
+      MaterializedViewConcurrentRefreshTestModel.refresh_view! concurrent: true
+
+      expect(sql_statements.grep_v(/^SELECT/)).to eq [
+        'BEGIN',
+        'REFRESH MATERIALIZED VIEW "materialized_view_refresh_test_models";',
+        "UPDATE active_record_views SET refreshed_at = current_timestamp AT TIME ZONE 'UTC' WHERE name = 'materialized_view_refresh_test_models';",
+        'COMMIT',
+
         'BEGIN',
         'REFRESH MATERIALIZED VIEW "materialized_view_refresh_test_models";',
         "UPDATE active_record_views SET refreshed_at = current_timestamp AT TIME ZONE 'UTC' WHERE name = 'materialized_view_refresh_test_models';",
         'COMMIT',
+
+        'BEGIN',
+        'REFRESH MATERIALIZED VIEW CONCURRENTLY "materialized_view_refresh_test_models";',
+        'ROLLBACK',
+
         'BEGIN',
         'REFRESH MATERIALIZED VIEW CONCURRENTLY "materialized_view_concurrent_refresh_test_models";',
         "UPDATE active_record_views SET refreshed_at = current_timestamp AT TIME ZONE 'UTC' WHERE name = 'materialized_view_concurrent_refresh_test_models';",
         'COMMIT',
-      ].each do |sql|
-        expect(ActiveRecord::Base.connection).to receive(:execute).with(sql).once.and_call_original
-      end
 
-      MaterializedViewRefreshTestModel.refresh_view!
-      MaterializedViewConcurrentRefreshTestModel.refresh_view! concurrent: true
+        'BEGIN',
+        'REFRESH MATERIALIZED VIEW "materialized_view_concurrent_refresh_test_models";',
+        "UPDATE active_record_views SET refreshed_at = current_timestamp AT TIME ZONE 'UTC' WHERE name = 'materialized_view_concurrent_refresh_test_models';",
+        'COMMIT',
+
+        'BEGIN',
+        'REFRESH MATERIALIZED VIEW CONCURRENTLY "materialized_view_concurrent_refresh_test_models";',
+        "UPDATE active_record_views SET refreshed_at = current_timestamp AT TIME ZONE 'UTC' WHERE name = 'materialized_view_concurrent_refresh_test_models';",
+        'COMMIT',
+      ]
     end
 
     it 'supports opportunistically refreshing materialized views concurrently' do
@@ -258,21 +332,28 @@ describe ActiveRecordViews::Extension do
         is_view 'SELECT 1 AS id;', materialized: true, unique_columns: [:id]
       end
 
-      [
+      sql_statements.clear
+
+      MaterializedViewAutoRefreshTestModel.refresh_view! concurrent: :auto
+      MaterializedViewAutoRefreshTestModel.refresh_view! concurrent: :auto
+      MaterializedViewAutoRefreshTestModel.refresh_view! concurrent: :auto
+
+      expect(sql_statements.grep_v(/^SELECT/)).to eq [
         'BEGIN',
         'REFRESH MATERIALIZED VIEW "materialized_view_auto_refresh_test_models";',
         "UPDATE active_record_views SET refreshed_at = current_timestamp AT TIME ZONE 'UTC' WHERE name = 'materialized_view_auto_refresh_test_models';",
         'COMMIT',
+
         'BEGIN',
         'REFRESH MATERIALIZED VIEW CONCURRENTLY "materialized_view_auto_refresh_test_models";',
         "UPDATE active_record_views SET refreshed_at = current_timestamp AT TIME ZONE 'UTC' WHERE name = 'materialized_view_auto_refresh_test_models';",
         'COMMIT',
-      ].each do |sql|
-        expect(ActiveRecord::Base.connection).to receive(:execute).with(sql).once.and_call_original
-      end
 
-      MaterializedViewAutoRefreshTestModel.refresh_view! concurrent: :auto
-      MaterializedViewAutoRefreshTestModel.refresh_view! concurrent: :auto
+        'BEGIN',
+        'REFRESH MATERIALIZED VIEW CONCURRENTLY "materialized_view_auto_refresh_test_models";',
+        "UPDATE active_record_views SET refreshed_at = current_timestamp AT TIME ZONE 'UTC' WHERE name = 'materialized_view_auto_refresh_test_models';",
+        'COMMIT',
+      ]
     end
 
     it 'raises an error when refreshing materialized views with invalid concurrent option' do
@@ -353,5 +434,32 @@ describe ActiveRecordViews::Extension do
         dependency_check_good_unmanageds
       ]
     end
+
+    context 'without create_enabled' do
+      around do |example|
+        without_create_enabled(&example)
+      end
+
+      it 'delays create_view until process_create_queue! is called' do
+        allow(ActiveRecordViews).to receive(:create_view).and_call_original
+
+        expect(ActiveRecordViews::Extension.create_queue.size).to eq 0
+        expect(ActiveRecordViews).to_not have_received(:create_view)
+
+        expect {
+          expect(HeredocTestModel.first.name).to eq 'Here document'
+        }.to raise_error ActiveRecord::StatementInvalid
+
+        expect(ActiveRecordViews::Extension.create_queue.size).to eq 1
+        expect(ActiveRecordViews).to_not have_received(:create_view)
+
+        ActiveRecordViews::Extension.process_create_queue!
+
+        expect(ActiveRecordViews::Extension.create_queue.size).to eq 0
+        expect(ActiveRecordViews).to have_received(:create_view)
+
+        expect(HeredocTestModel.first.name).to eq 'Here document'
+      end
+    end
   end
 end