scenic-jets 1.5.4

data/spec/scenic/command_recorder/statement_arguments_spec.rb

@@ -0,0 +1,41 @@
+require "spec_helper"
+
+module Scenic::CommandRecorder
+  describe StatementArguments do
+    describe "#view" do
+      it "is the view name" do
+        raw_args = [:spaceships, { foo: :bar }]
+        args = StatementArguments.new(raw_args)
+
+        expect(args.view).to eq :spaceships
+      end
+    end
+
+    describe "#revert_to_version" do
+      it "is the revert_to_version from the keyword arguments" do
+        raw_args = [:spaceships, { revert_to_version: 42 }]
+        args = StatementArguments.new(raw_args)
+
+        expect(args.revert_to_version).to eq 42
+      end
+
+      it "is nil if the revert_to_version was not supplied" do
+        raw_args = [:spaceships, { foo: :bar }]
+        args = StatementArguments.new(raw_args)
+
+        expect(args.revert_to_version).to be nil
+      end
+    end
+
+    describe "#invert_version" do
+      it "returns object with version set to revert_to_version" do
+        raw_args = [:meatballs, { version: 42, revert_to_version: 15 }]
+
+        inverted_args = StatementArguments.new(raw_args).invert_version
+
+        expect(inverted_args.version).to eq 15
+        expect(inverted_args.revert_to_version).to be nil
+      end
+    end
+  end
+end

data/spec/scenic/command_recorder_spec.rb

@@ -0,0 +1,111 @@
+require "spec_helper"
+
+describe Scenic::CommandRecorder do
+  describe "#create_view" do
+    it "records the created view" do
+      recorder.create_view :greetings
+
+      expect(recorder.commands).to eq [[:create_view, [:greetings], nil]]
+    end
+
+    it "reverts to drop_view when not passed a version" do
+      recorder.revert { recorder.create_view :greetings }
+
+      expect(recorder.commands).to eq [[:drop_view, [:greetings]]]
+    end
+
+    it "reverts to drop_view when passed a version" do
+      recorder.revert { recorder.create_view :greetings, version: 2 }
+
+      expect(recorder.commands).to eq [[:drop_view, [:greetings]]]
+    end
+
+    it "reverts materialized views appropriately" do
+      recorder.revert { recorder.create_view :greetings, materialized: true }
+
+      expect(recorder.commands).to eq [
+        [:drop_view, [:greetings, materialized: true]],
+      ]
+    end
+  end
+
+  describe "#drop_view" do
+    it "records the dropped view" do
+      recorder.drop_view :users
+
+      expect(recorder.commands).to eq [[:drop_view, [:users], nil]]
+    end
+
+    it "reverts to create_view with specified revert_to_version" do
+      args = [:users, { revert_to_version: 3 }]
+      revert_args = [:users, { version: 3 }]
+
+      recorder.revert { recorder.drop_view(*args) }
+
+      expect(recorder.commands).to eq [[:create_view, revert_args]]
+    end
+
+    it "raises when reverting without revert_to_version set" do
+      args = [:users, { another_argument: 1 }]
+
+      expect { recorder.revert { recorder.drop_view(*args) } }
+        .to raise_error(ActiveRecord::IrreversibleMigration)
+    end
+  end
+
+  describe "#update_view" do
+    it "records the updated view" do
+      args = [:users, { version: 2 }]
+
+      recorder.update_view(*args)
+
+      expect(recorder.commands).to eq [[:update_view, args, nil]]
+    end
+
+    it "reverts to update_view with the specified revert_to_version" do
+      args = [:users, { version: 2, revert_to_version: 1 }]
+      revert_args = [:users, { version: 1 }]
+
+      recorder.revert { recorder.update_view(*args) }
+
+      expect(recorder.commands).to eq [[:update_view, revert_args]]
+    end
+
+    it "raises when reverting without revert_to_version set" do
+      args = [:users, { version: 42, another_argument: 1 }]
+
+      expect { recorder.revert { recorder.update_view(*args) } }
+        .to raise_error(ActiveRecord::IrreversibleMigration)
+    end
+  end
+
+  describe "#replace_view" do
+    it "records the replaced view" do
+      args = [:users, { version: 2 }]
+
+      recorder.replace_view(*args)
+
+      expect(recorder.commands).to eq [[:replace_view, args, nil]]
+    end
+
+    it "reverts to replace_view with the specified revert_to_version" do
+      args = [:users, { version: 2, revert_to_version: 1 }]
+      revert_args = [:users, { version: 1 }]
+
+      recorder.revert { recorder.replace_view(*args) }
+
+      expect(recorder.commands).to eq [[:replace_view, revert_args]]
+    end
+
+    it "raises when reverting without revert_to_version set" do
+      args = [:users, { version: 42, another_argument: 1 }]
+
+      expect { recorder.revert { recorder.replace_view(*args) } }
+        .to raise_error(ActiveRecord::IrreversibleMigration)
+    end
+  end
+
+  def recorder
+    @recorder ||= ActiveRecord::Migration::CommandRecorder.new
+  end
+end

data/spec/scenic/configuration_spec.rb

@@ -0,0 +1,27 @@
+require "spec_helper"
+
+module Scenic
+  describe Configuration do
+    after { restore_default_config }
+
+    it "defaults the database adapter to postgres" do
+      expect(Scenic.configuration.database).to be_a Adapters::Postgres
+      expect(Scenic.database).to be_a Adapters::Postgres
+    end
+
+    it "allows the database adapter to be set" do
+      adapter = double("Scenic Adapter")
+
+      Scenic.configure do |config|
+        config.database = adapter
+      end
+
+      expect(Scenic.configuration.database).to eq adapter
+      expect(Scenic.database).to eq adapter
+    end
+
+    def restore_default_config
+      Scenic.configuration = Configuration.new
+    end
+  end
+end

data/spec/scenic/definition_spec.rb

@@ -0,0 +1,62 @@
+require "spec_helper"
+
+module Scenic
+  describe Definition do
+    describe "to_sql" do
+      it "returns the content of a view definition" do
+        sql_definition = "SELECT text 'Hi' as greeting"
+        allow(File).to receive(:read).and_return(sql_definition)
+
+        definition = Definition.new("searches", 1)
+
+        expect(definition.to_sql).to eq sql_definition
+      end
+
+      it "raises an error if the file is empty" do
+        allow(File).to receive(:read).and_return("")
+
+        expect do
+          Definition.new("searches", 1).to_sql
+        end.to raise_error RuntimeError
+      end
+    end
+
+    describe "path" do
+      it "returns a sql file in db/views with padded version and view name" do
+        expected = "db/views/searches_v01.sql"
+
+        definition = Definition.new("searches", 1)
+
+        expect(definition.path).to eq expected
+      end
+
+      it "handles schema qualified view names" do
+        definition = Definition.new("non_public.searches", 1)
+
+        expect(definition.path).to eq "db/views/non_public_searches_v01.sql"
+      end
+    end
+
+    describe "full_path" do
+      it "joins the path with Rails.root" do
+        definition = Definition.new("searches", 15)
+
+        expect(definition.full_path).to eq Rails.root.join(definition.path)
+      end
+    end
+
+    describe "version" do
+      it "pads the version number with 0" do
+        definition = Definition.new(:_, 1)
+
+        expect(definition.version).to eq "01"
+      end
+
+      it "doesn't pad more than 2 characters" do
+        definition = Definition.new(:_, 15)
+
+        expect(definition.version).to eq "15"
+      end
+    end
+  end
+end

data/spec/scenic/schema_dumper_spec.rb

@@ -0,0 +1,115 @@
+require "spec_helper"
+
+class Search < ActiveRecord::Base; end
+
+class SearchInAHaystack < ActiveRecord::Base
+  self.table_name = '"search in a haystack"'
+end
+
+describe Scenic::SchemaDumper, :db do
+  it "dumps a create_view for a view in the database" do
+    view_definition = "SELECT 'needle'::text AS haystack"
+    Search.connection.create_view :searches, sql_definition: view_definition
+    stream = StringIO.new
+
+    ActiveRecord::SchemaDumper.dump(Search.connection, stream)
+
+    output = stream.string
+
+    expect(output).to include 'create_view "searches", sql_definition: <<-SQL'
+    expect(output).to include view_definition
+
+    Search.connection.drop_view :searches
+
+    silence_stream(STDOUT) { eval(output) }
+
+    expect(Search.first.haystack).to eq "needle"
+  end
+
+  it "dumps a create_view for a materialized view in the database" do
+    view_definition = "SELECT 'needle'::text AS haystack"
+    Search.connection.create_view :searches, materialized: true, sql_definition: view_definition
+    stream = StringIO.new
+
+    ActiveRecord::SchemaDumper.dump(Search.connection, stream)
+
+    output = stream.string
+
+    expect(output).to include 'create_view "searches", materialized: true, sql_definition: <<-SQL'
+    expect(output).to include view_definition
+  end
+
+  context "with views in non public schemas" do
+    it "dumps a create_view including namespace for a view in the database" do
+      view_definition = "SELECT 'needle'::text AS haystack"
+      Search.connection.execute "CREATE SCHEMA scenic; SET search_path TO scenic, public"
+      Search.connection.create_view :"scenic.searches", sql_definition: view_definition
+      stream = StringIO.new
+
+      ActiveRecord::SchemaDumper.dump(Search.connection, stream)
+
+      output = stream.string
+      expect(output).to include 'create_view "scenic.searches",'
+
+      Search.connection.drop_view :'scenic.searches'
+    end
+  end
+
+  it "ignores tables internal to Rails" do
+    view_definition = "SELECT 'needle'::text AS haystack"
+    Search.connection.create_view :searches, sql_definition: view_definition
+    stream = StringIO.new
+
+    ActiveRecord::SchemaDumper.dump(Search.connection, stream)
+
+    output = stream.string
+
+    expect(output).to include 'create_view "searches"'
+    expect(output).not_to include "ar_internal_metadata"
+    expect(output).not_to include "schema_migrations"
+  end
+
+  context "with views using unexpected characters in name" do
+    it "dumps a create_view for a view in the database" do
+      view_definition = "SELECT 'needle'::text AS haystack"
+      Search.connection.create_view '"search in a haystack"', sql_definition: view_definition
+      stream = StringIO.new
+
+      ActiveRecord::SchemaDumper.dump(Search.connection, stream)
+
+      output = stream.string
+      expect(output).to include 'create_view "\"search in a haystack\"",'
+      expect(output).to include view_definition
+
+      Search.connection.drop_view :'"search in a haystack"'
+
+      silence_stream(STDOUT) { eval(output) }
+
+      expect(SearchInAHaystack.take.haystack).to eq "needle"
+    end
+  end
+
+  context "with views using unexpected characters, name including namespace" do
+    it "dumps a create_view for a view in the database" do
+      view_definition = "SELECT 'needle'::text AS haystack"
+      Search.connection.execute(
+        "CREATE SCHEMA scenic; SET search_path TO scenic, public",
+      )
+      Search.connection.create_view 'scenic."search in a haystack"',
+        sql_definition: view_definition
+      stream = StringIO.new
+
+      ActiveRecord::SchemaDumper.dump(Search.connection, stream)
+
+      output = stream.string
+      expect(output).to include 'create_view "scenic.\"search in a haystack\"",'
+      expect(output).to include view_definition
+
+      Search.connection.drop_view :'scenic."search in a haystack"'
+
+      silence_stream(STDOUT) { eval(output) }
+
+      expect(SearchInAHaystack.take.haystack).to eq "needle"
+    end
+  end
+end

data/spec/scenic/statements_spec.rb

@@ -0,0 +1,199 @@
+require "spec_helper"
+
+module Scenic
+  describe Scenic::Statements do
+    before do
+      adapter = instance_double("Scenic::Adapters::Postgres").as_null_object
+      allow(Scenic).to receive(:database).and_return(adapter)
+    end
+
+    describe "create_view" do
+      it "creates a view from a file" do
+        version = 15
+        definition_stub = instance_double("Definition", to_sql: "foo")
+        allow(Definition).to receive(:new)
+          .with(:views, version)
+          .and_return(definition_stub)
+
+        connection.create_view :views, version: version
+
+        expect(Scenic.database).to have_received(:create_view)
+          .with(:views, definition_stub.to_sql)
+      end
+
+      it "creates a view from a text definition" do
+        sql_definition = "a defintion"
+
+        connection.create_view(:views, sql_definition: sql_definition)
+
+        expect(Scenic.database).to have_received(:create_view)
+          .with(:views, sql_definition)
+      end
+
+      it "creates version 1 of the view if neither version nor sql_defintion are provided" do
+        version = 1
+        definition_stub = instance_double("Definition", to_sql: "foo")
+        allow(Definition).to receive(:new)
+          .with(:views, version)
+          .and_return(definition_stub)
+
+        connection.create_view :views
+
+        expect(Scenic.database).to have_received(:create_view)
+          .with(:views, definition_stub.to_sql)
+      end
+
+      it "raises an error if both version and sql_defintion are provided" do
+        expect do
+          connection.create_view :foo, version: 1, sql_definition: "a defintion"
+        end.to raise_error ArgumentError
+      end
+    end
+
+    describe "create_view :materialized" do
+      it "sends the create_materialized_view message" do
+        definition = instance_double("Scenic::Definition", to_sql: "definition")
+        allow(Definition).to receive(:new).and_return(definition)
+
+        connection.create_view(:views, version: 1, materialized: true)
+
+        expect(Scenic.database).to have_received(:create_materialized_view)
+          .with(:views, definition.to_sql, no_data: false)
+      end
+    end
+
+    describe "create_view :materialized with :no_data" do
+      it "sends the create_materialized_view message" do
+        definition = instance_double("Scenic::Definition", to_sql: "definition")
+        allow(Definition).to receive(:new).and_return(definition)
+
+        connection.create_view(
+          :views,
+          version: 1,
+          materialized: { no_data: true },
+        )
+
+        expect(Scenic.database).to have_received(:create_materialized_view)
+          .with(:views, definition.to_sql, no_data: true)
+      end
+    end
+
+    describe "drop_view" do
+      it "removes a view from the database" do
+        connection.drop_view :name
+
+        expect(Scenic.database).to have_received(:drop_view).with(:name)
+      end
+    end
+
+    describe "drop_view :materialized" do
+      it "removes a materialized view from the database" do
+        connection.drop_view :name, materialized: true
+
+        expect(Scenic.database).to have_received(:drop_materialized_view)
+      end
+    end
+
+    describe "update_view" do
+      it "updates the view in the database" do
+        definition = instance_double("Definition", to_sql: "definition")
+        allow(Definition).to receive(:new)
+          .with(:name, 3)
+          .and_return(definition)
+
+        connection.update_view(:name, version: 3)
+
+        expect(Scenic.database).to have_received(:update_view)
+          .with(:name, definition.to_sql)
+      end
+
+      it "updates a view from a text definition" do
+        sql_definition = "a defintion"
+
+        connection.update_view(:name, sql_definition: sql_definition)
+
+        expect(Scenic.database).to have_received(:update_view)
+          .with(:name, sql_definition)
+      end
+
+      it "updates the materialized view in the database" do
+        definition = instance_double("Definition", to_sql: "definition")
+        allow(Definition).to receive(:new)
+          .with(:name, 3)
+          .and_return(definition)
+
+        connection.update_view(:name, version: 3, materialized: true)
+
+        expect(Scenic.database).to have_received(:update_materialized_view)
+          .with(:name, definition.to_sql, no_data: false)
+      end
+
+      it "updates the materialized view in the database with NO DATA" do
+        definition = instance_double("Definition", to_sql: "definition")
+        allow(Definition).to receive(:new)
+          .with(:name, 3)
+          .and_return(definition)
+
+        connection.update_view(
+          :name,
+          version: 3,
+          materialized: { no_data: true },
+        )
+
+        expect(Scenic.database).to have_received(:update_materialized_view)
+          .with(:name, definition.to_sql, no_data: true)
+      end
+
+      it "raises an error if not supplied a version or sql_defintion" do
+        expect { connection.update_view :views }.to raise_error(
+          ArgumentError,
+          /sql_definition or version must be specified/,
+        )
+      end
+
+      it "raises an error if both version and sql_defintion are provided" do
+        expect do
+          connection.update_view(
+            :views,
+            version: 1,
+            sql_definition: "a defintion",
+          )
+        end.to raise_error ArgumentError, /cannot both be set/
+      end
+    end
+
+    describe "replace_view" do
+      it "replaces the view in the database" do
+        definition = instance_double("Definition", to_sql: "definition")
+        allow(Definition).to receive(:new)
+          .with(:name, 3)
+          .and_return(definition)
+
+        connection.replace_view(:name, version: 3)
+
+        expect(Scenic.database).to have_received(:replace_view)
+          .with(:name, definition.to_sql)
+      end
+
+      it "fails to replace the materialized view in the database" do
+        definition = instance_double("Definition", to_sql: "definition")
+        allow(Definition).to receive(:new)
+          .with(:name, 3)
+          .and_return(definition)
+
+        expect do
+          connection.replace_view(:name, version: 3, materialized: true)
+        end.to raise_error(ArgumentError, /Cannot replace materialized views/)
+      end
+
+      it "raises an error if not supplied a version" do
+        expect { connection.replace_view :views }
+          .to raise_error(ArgumentError, /version is required/)
+      end
+    end
+
+    def connection
+      Class.new { extend Statements }
+    end
+  end
+end