scenic-jets 1.5.4

data/spec/dummy/config/application.rb

@@ -0,0 +1,15 @@
+require File.expand_path("../boot", __FILE__)
+
+# Pick the frameworks you want:
+require "active_record/railtie"
+
+Bundler.require(*Rails.groups)
+require "scenic"
+
+module Dummy
+  class Application < Rails::Application
+    config.cache_classes = true
+    config.eager_load = false
+    config.active_support.deprecation = :stderr
+  end
+end

data/spec/dummy/config/boot.rb

@@ -0,0 +1,5 @@
+# Set up gems listed in the Gemfile.
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../../../Gemfile", __FILE__)
+
+require "bundler/setup" if File.exist?(ENV["BUNDLE_GEMFILE"])
+$LOAD_PATH.unshift File.expand_path("../../../../lib", __FILE__)

data/spec/dummy/config/database.yml

@@ -0,0 +1,14 @@
+development: &default
+  adapter: postgresql
+  database: dummy_development
+  encoding: unicode
+  host: localhost
+  pool: 5
+  <% if ENV.fetch("GITHUB_ACTIONS", false) %>
+  username: <%= ENV.fetch("POSTGRES_USER") %>
+  password: <%= ENV.fetch("POSTGRES_PASSWORD") %>
+  <% end %>
+
+test:
+  <<: *default
+  database: dummy_test

data/spec/dummy/config/environment.rb

@@ -0,0 +1,5 @@
+# Load the Rails application.
+require File.expand_path("../application", __FILE__)
+
+# Initialize the Rails application.
+Rails.application.initialize!

data/spec/generators/scenic/model/model_generator_spec.rb

@@ -0,0 +1,36 @@
+require "spec_helper"
+require "generators/scenic/model/model_generator"
+
+module Scenic::Generators
+  describe ModelGenerator, :generator do
+    before do
+      allow(ViewGenerator).to receive(:new)
+        .and_return(
+          instance_double("Scenic::Generators::ViewGenerator").as_null_object,
+        )
+    end
+
+    it "invokes the view generator" do
+      run_generator ["current_customer"]
+
+      expect(ViewGenerator).to have_received(:new)
+    end
+
+    it "creates a migration to create the view" do
+      run_generator ["current_customer"]
+      model_definition = file("app/models/current_customer.rb")
+      expect(model_definition).to exist
+      expect(model_definition).to have_correct_syntax
+      expect(model_definition).not_to contain("self.refresh")
+      expect(model_definition).to have_correct_syntax
+    end
+
+    it "adds a refresh method to materialized models" do
+      run_generator ["active_user", "--materialized"]
+      model_definition = file("app/models/active_user.rb")
+
+      expect(model_definition).to contain("self.refresh")
+      expect(model_definition).to have_correct_syntax
+    end
+  end
+end

data/spec/generators/scenic/view/view_generator_spec.rb

@@ -0,0 +1,57 @@
+require "spec_helper"
+require "generators/scenic/view/view_generator"
+
+describe Scenic::Generators::ViewGenerator, :generator do
+  it "creates view definition and migration files" do
+    migration = file("db/migrate/create_searches.rb")
+    view_definition = file("db/views/searches_v01.sql")
+
+    run_generator ["search"]
+
+    expect(migration).to be_a_migration
+    expect(view_definition).to exist
+  end
+
+  it "updates an existing view" do
+    with_view_definition("searches", 1, "hello") do
+      migration = file("db/migrate/update_searches_to_version_2.rb")
+      view_definition = file("db/views/searches_v02.sql")
+      allow(Dir).to receive(:entries).and_return(["searches_v01.sql"])
+
+      run_generator ["search"]
+
+      expect(migration).to be_a_migration
+      expect(view_definition).to exist
+    end
+  end
+
+  it "adds 'materialized: true' to the migration if view is materialized" do
+    with_view_definition("aired_episodes", 1, "hello") do
+      allow(Dir).to receive(:entries).and_return(["aired_episodes_v01.sql"])
+
+      run_generator ["aired_episode", "--materialized"]
+      migration = migration_file(
+        "db/migrate/update_aired_episodes_to_version_2.rb",
+      )
+      expect(migration).to contain "materialized: true"
+    end
+  end
+
+  context "for views created in a schema other than 'public'" do
+    it "creates a view definition" do
+      view_definition = file("db/views/non_public_searches_v01.sql")
+
+      run_generator ["non_public.search"]
+
+      expect(view_definition).to exist
+    end
+
+    it "creates a migration file" do
+      run_generator ["non_public.search"]
+
+      migration = migration_file("db/migrate/create_non_public_searches.rb")
+      expect(migration).to contain(/class CreateNonPublicSearches/)
+      expect(migration).to contain(/create_view "non_public.searches"/)
+    end
+  end
+end

data/spec/integration/revert_spec.rb

@@ -0,0 +1,74 @@
+require "spec_helper"
+
+describe "Reverting scenic schema statements", :db do
+  around do |example|
+    with_view_definition :greetings, 1, "SELECT text 'hola' AS greeting" do
+      example.run
+    end
+  end
+
+  it "reverts dropped view to specified version" do
+    run_migration(migration_for_create, :up)
+    run_migration(migration_for_drop, :up)
+    run_migration(migration_for_drop, :down)
+
+    expect { execute("SELECT * from greetings") }
+      .not_to raise_error
+  end
+
+  it "reverts updated view to specified version" do
+    with_view_definition :greetings, 2, "SELECT text 'good day' AS greeting" do
+      run_migration(migration_for_create, :up)
+      run_migration(migration_for_update, :up)
+      run_migration(migration_for_update, :down)
+
+      greeting = execute("SELECT * from greetings")[0]["greeting"]
+
+      expect(greeting).to eq "hola"
+    end
+  end
+
+  def migration_for_create
+    Class.new(migration_class) do
+      def change
+        create_view :greetings
+      end
+    end
+  end
+
+  def migration_for_drop
+    Class.new(migration_class) do
+      def change
+        drop_view :greetings, revert_to_version: 1
+      end
+    end
+  end
+
+  def migration_for_update
+    Class.new(migration_class) do
+      def change
+        update_view :greetings, version: 2, revert_to_version: 1
+      end
+    end
+  end
+
+  def migration_class
+    if Rails::VERSION::MAJOR >= 5
+      ::ActiveRecord::Migration[5.0]
+    else
+      ::ActiveRecord::Migration
+    end
+  end
+
+  def run_migration(migration, directions)
+    silence_stream(STDOUT) do
+      Array.wrap(directions).each do |direction|
+        migration.migrate(direction)
+      end
+    end
+  end
+
+  def execute(sql)
+    ActiveRecord::Base.connection.execute(sql)
+  end
+end

data/spec/scenic/adapters/postgres/connection_spec.rb

@@ -0,0 +1,79 @@
+require "spec_helper"
+
+module Scenic
+  module Adapters
+    describe Postgres::Connection do
+      describe "supports_materialized_views?" do
+        context "supports_materialized_views? was defined on connection" do
+          it "uses the previously defined version" do
+            base_response = double("response from base connection")
+            base_connection = double(
+              "Connection",
+              supports_materialized_views?: base_response,
+            )
+
+            connection = Postgres::Connection.new(base_connection)
+
+            expect(connection.supports_materialized_views?).to be base_response
+          end
+        end
+
+        context "supports_materialized_views? is not already defined" do
+          it "is true if postgres version is at least than 9.3.0" do
+            base_connection = double("Connection", postgresql_version: 90300)
+
+            connection = Postgres::Connection.new(base_connection)
+
+            expect(connection.supports_materialized_views?).to be true
+          end
+
+          it "is false if postgres version is less than 9.3.0" do
+            base_connection = double("Connection", postgresql_version: 90299)
+
+            connection = Postgres::Connection.new(base_connection)
+
+            expect(connection.supports_materialized_views?).to be false
+          end
+        end
+      end
+
+      describe "#postgresql_version" do
+        it "uses the public method on the provided connection if defined" do
+          base_connection = Class.new do
+            def postgresql_version
+              123
+            end
+          end
+
+          connection = Postgres::Connection.new(base_connection.new)
+
+          expect(connection.postgresql_version).to eq 123
+        end
+
+        it "uses the protected method if the underlying method is not public" do
+          base_connection = Class.new do
+            protected
+
+            def postgresql_version
+              123
+            end
+          end
+
+          connection = Postgres::Connection.new(base_connection.new)
+
+          expect(connection.postgresql_version).to eq 123
+        end
+      end
+
+      describe "#supports_concurrent_refresh" do
+        it "is true if postgres version is at least 9.4.0" do
+          base_connection = double("Connection", postgresql_version: 90400)
+
+          connection = Postgres::Connection.new(base_connection)
+
+          expect(connection.supports_concurrent_refreshes?).to be true
+        end
+      end
+    end
+  end
+end

data/spec/scenic/adapters/postgres/refresh_dependencies_spec.rb

@@ -0,0 +1,82 @@
+require "spec_helper"
+
+module Scenic
+  module Adapters
+    describe Postgres::RefreshDependencies, :db do
+      context "view has dependencies" do
+        let(:adapter) { Postgres.new }
+
+        before do
+          adapter.create_materialized_view(
+            "first",
+            "SELECT text 'hi' AS greeting",
+          )
+          adapter.create_materialized_view(
+            "second",
+            "SELECT * FROM first",
+          )
+          adapter.create_materialized_view(
+            "third",
+            "SELECT * FROM first UNION SELECT * FROM second",
+          )
+          adapter.create_materialized_view(
+            "fourth_1",
+            "SELECT * FROM third",
+          )
+          adapter.create_materialized_view(
+            "x_fourth",
+            "SELECT * FROM fourth_1",
+          )
+          adapter.create_materialized_view(
+            "fourth",
+            "SELECT * FROM fourth_1 UNION SELECT * FROM x_fourth",
+          )
+
+          expect(adapter).to receive(:refresh_materialized_view)
+            .with("public.first", concurrently: true).ordered
+          expect(adapter).to receive(:refresh_materialized_view)
+            .with("public.second", concurrently: true).ordered
+          expect(adapter).to receive(:refresh_materialized_view)
+            .with("public.third", concurrently: true).ordered
+          expect(adapter).to receive(:refresh_materialized_view)
+            .with("public.fourth_1", concurrently: true).ordered
+          expect(adapter).to receive(:refresh_materialized_view)
+            .with("public.x_fourth", concurrently: true).ordered
+        end
+
+        it "refreshes in the right order when called without namespace" do
+          described_class.call(
+            :fourth,
+            adapter,
+            ActiveRecord::Base.connection,
+            concurrently: true,
+          )
+        end
+
+        it "refreshes in the right order when called with namespace" do
+          described_class.call(
+            "public.fourth",
+            adapter,
+            ActiveRecord::Base.connection,
+            concurrently: true,
+          )
+        end
+      end
+
+      context "view has no dependencies" do
+        it "does not raise an error" do
+          adapter = Postgres.new
+
+          adapter.create_materialized_view(
+            "first",
+            "SELECT text 'hi' AS greeting",
+          )
+
+          expect {
+            described_class.call(:first, adapter, ActiveRecord::Base.connection)
+          }.not_to raise_error
+        end
+      end
+    end
+  end
+end

data/spec/scenic/adapters/postgres/views_spec.rb

@@ -0,0 +1,37 @@
+require "spec_helper"
+
+module Scenic
+  module Adapters
+    describe Postgres::Views, :db do
+      it "returns scenic view objects for plain old views" do
+        connection = ActiveRecord::Base.connection
+        connection.execute <<-SQL
+          CREATE VIEW children AS SELECT text 'Elliot' AS name
+        SQL
+
+        views = Postgres::Views.new(connection).all
+        first = views.first
+
+        expect(views.size).to eq 1
+        expect(first.name).to eq "children"
+        expect(first.materialized).to be false
+        expect(first.definition).to eq "SELECT 'Elliot'::text AS name;"
+      end
+
+      it "returns scenic view objects for materialized views" do
+        connection = ActiveRecord::Base.connection
+        connection.execute <<-SQL
+          CREATE MATERIALIZED VIEW children AS SELECT text 'Owen' AS name
+        SQL
+
+        views = Postgres::Views.new(connection).all
+        first = views.first
+
+        expect(views.size).to eq 1
+        expect(first.name).to eq "children"
+        expect(first.materialized).to be true
+        expect(first.definition).to eq "SELECT 'Owen'::text AS name;"
+      end
+    end
+  end
+end

data/spec/scenic/adapters/postgres_spec.rb

@@ -0,0 +1,209 @@
+require "spec_helper"
+
+module Scenic
+  module Adapters
+    describe Postgres, :db do
+      describe "#create_view" do
+        it "successfully creates a view" do
+          adapter = Postgres.new
+
+          adapter.create_view("greetings", "SELECT text 'hi' AS greeting")
+
+          expect(adapter.views.map(&:name)).to include("greetings")
+        end
+      end
+
+      describe "#create_materialized_view" do
+        it "successfully creates a materialized view" do
+          adapter = Postgres.new
+
+          adapter.create_materialized_view(
+            "greetings",
+            "SELECT text 'hi' AS greeting",
+          )
+
+          view = adapter.views.first
+          expect(view.name).to eq("greetings")
+          expect(view.materialized).to eq true
+        end
+
+        it "handles semicolon in definition when using `with no data`" do
+          adapter = Postgres.new
+
+          adapter.create_materialized_view(
+            "greetings",
+            "SELECT text 'hi' AS greeting; \n",
+            no_data: true,
+          )
+
+          view = adapter.views.first
+          expect(view.name).to eq("greetings")
+          expect(view.materialized).to eq true
+        end
+
+        it "raises an exception if the version of PostgreSQL is too old" do
+          connection = double("Connection", supports_materialized_views?: false)
+          connectable = double("Connectable", connection: connection)
+          adapter = Postgres.new(connectable)
+          err = Scenic::Adapters::Postgres::MaterializedViewsNotSupportedError
+
+          expect { adapter.create_materialized_view("greetings", "select 1") }
+            .to raise_error err
+        end
+      end
+
+      describe "#replace_view" do
+        it "successfully replaces a view" do
+          adapter = Postgres.new
+
+          adapter.create_view("greetings", "SELECT text 'hi' AS greeting")
+
+          view = adapter.views.first.definition
+          expect(view).to eql "SELECT 'hi'::text AS greeting;"
+
+          adapter.replace_view("greetings", "SELECT text 'hello' AS greeting")
+
+          view = adapter.views.first.definition
+          expect(view).to eql "SELECT 'hello'::text AS greeting;"
+        end
+      end
+
+      describe "#drop_view" do
+        it "successfully drops a view" do
+          adapter = Postgres.new
+
+          adapter.create_view("greetings", "SELECT text 'hi' AS greeting")
+          adapter.drop_view("greetings")
+
+          expect(adapter.views.map(&:name)).not_to include("greetings")
+        end
+      end
+
+      describe "#drop_materialized_view" do
+        it "successfully drops a materialized view" do
+          adapter = Postgres.new
+
+          adapter.create_materialized_view(
+            "greetings",
+            "SELECT text 'hi' AS greeting",
+          )
+          adapter.drop_materialized_view("greetings")
+
+          expect(adapter.views.map(&:name)).not_to include("greetings")
+        end
+
+        it "raises an exception if the version of PostgreSQL is too old" do
+          connection = double("Connection", supports_materialized_views?: false)
+          connectable = double("Connectable", connection: connection)
+          adapter = Postgres.new(connectable)
+          err = Scenic::Adapters::Postgres::MaterializedViewsNotSupportedError
+
+          expect { adapter.drop_materialized_view("greetings") }
+            .to raise_error err
+        end
+      end
+
+      describe "#refresh_materialized_view" do
+        it "raises an exception if the version of PostgreSQL is too old" do
+          connection = double("Connection", supports_materialized_views?: false)
+          connectable = double("Connectable", connection: connection)
+          adapter = Postgres.new(connectable)
+          err = Scenic::Adapters::Postgres::MaterializedViewsNotSupportedError
+
+          expect { adapter.refresh_materialized_view(:tests) }
+            .to raise_error err
+        end
+
+        it "can refresh the views dependencies first" do
+          connection = double("Connection").as_null_object
+          connectable = double("Connectable", connection: connection)
+          adapter = Postgres.new(connectable)
+          expect(Scenic::Adapters::Postgres::RefreshDependencies)
+            .to receive(:call)
+            .with(:tests, adapter, connection, concurrently: true)
+
+          adapter.refresh_materialized_view(
+            :tests,
+            cascade: true,
+            concurrently: true,
+          )
+        end
+
+        context "refreshing concurrently" do
+          it "raises descriptive error if concurrent refresh is not possible" do
+            adapter = Postgres.new
+            adapter.create_materialized_view(:tests, "SELECT text 'hi' as text")
+
+            expect {
+              adapter.refresh_materialized_view(:tests, concurrently: true)
+            }.to raise_error(/Create a unique index with no WHERE clause/)
+          end
+
+          it "raises an exception if the version of PostgreSQL is too old" do
+            connection = double("Connection", postgresql_version: 90300)
+            connectable = double("Connectable", connection: connection)
+            adapter = Postgres.new(connectable)
+            e = Scenic::Adapters::Postgres::ConcurrentRefreshesNotSupportedError
+
+            expect {
+              adapter.refresh_materialized_view(:tests, concurrently: true)
+            }.to raise_error e
+          end
+        end
+      end
+
+      describe "#views" do
+        it "returns the views defined on this connection" do
+          adapter = Postgres.new
+
+          ActiveRecord::Base.connection.execute <<-SQL
+            CREATE VIEW parents AS SELECT text 'Joe' AS name
+          SQL
+
+          ActiveRecord::Base.connection.execute <<-SQL
+            CREATE VIEW children AS SELECT text 'Owen' AS name
+          SQL
+
+          ActiveRecord::Base.connection.execute <<-SQL
+            CREATE MATERIALIZED VIEW people AS
+            SELECT name FROM parents UNION SELECT name FROM children
+          SQL
+
+          ActiveRecord::Base.connection.execute <<-SQL
+            CREATE VIEW people_with_names AS
+            SELECT name FROM people
+            WHERE name IS NOT NULL
+          SQL
+
+          expect(adapter.views.map(&:name)).to eq [
+            "parents",
+            "children",
+            "people",
+            "people_with_names",
+          ]
+        end
+
+        context "with views in non public schemas" do
+          it "returns also the non public views" do
+            adapter = Postgres.new
+
+            ActiveRecord::Base.connection.execute <<-SQL
+              CREATE VIEW parents AS SELECT text 'Joe' AS name
+            SQL
+
+            ActiveRecord::Base.connection.execute <<-SQL
+              CREATE SCHEMA scenic;
+              CREATE VIEW scenic.parents AS SELECT text 'Maarten' AS name;
+              SET search_path TO scenic, public;
+            SQL
+
+            expect(adapter.views.map(&:name)).to eq [
+              "parents",
+              "scenic.parents",
+            ]
+          end
+        end
+      end
+    end
+  end
+end