dumbo 0.0.1 → 0.0.3

data/lib/dumbo/type.rb

@@ -1,6 +1,6 @@
 module Dumbo
   class Type < PgObject
-    attr_accessor  :name, :type, :typrelid
+    attr_accessor :name, :type, :typrelid
     identfied_by :name
 
     def load_attributes
@@ -24,8 +24,7 @@ module Dumbo
     end
 
     def drop
-      "DROP TYPE #{name}"
+      "DROP TYPE #{name};"
     end
-
   end
-end
+end

data/lib/dumbo/version.rb

@@ -1,3 +1,3 @@
 module Dumbo
-  VERSION = "0.0.1"
+  VERSION = '0.0.3'
 end

data/spec/aggregate_spec.rb

@@ -1,24 +1,23 @@
 require 'spec_helper'
 describe Dumbo::Aggregate do
   let(:avg) do
-    oid = sql("SELECT p.oid
+    oid = query("SELECT p.oid
               FROM pg_proc p
               JOIN pg_aggregate ag ON p.oid = ag.aggfnoid
-              WHERE proname='avg' AND pg_get_function_arguments(p.oid) = 'integer'",'oid').first
+              WHERE proname='avg' AND pg_get_function_arguments(p.oid) = 'integer'").first['oid']
     Dumbo::Aggregate.new(oid)
   end
 
   let(:min) do
-    oid = sql("SELECT p.oid
+    oid = query("SELECT p.oid
               FROM pg_proc p
               JOIN pg_aggregate ag ON p.oid = ag.aggfnoid
-              WHERE proname='min' AND pg_get_function_arguments(p.oid) = 'integer'",'oid').first
+              WHERE proname='min' AND pg_get_function_arguments(p.oid) = 'integer'").first['oid']
     Dumbo::Aggregate.new(oid)
   end
 
-
-  it "avg should have a sql representation" do
-      avg.to_sql.should eq <<-SQL.gsub(/^ {6}/, '')
+  it 'avg should have a sql representation' do
+    expect(avg.to_sql).to eq <<-SQL.gsub(/^ {6}/, '')
       CREATE AGGREGATE avg(integer) (
         SFUNC = int4_avg_accum,
         STYPE = int8[],
@@ -28,8 +27,8 @@ describe Dumbo::Aggregate do
       SQL
   end
 
-  it "min should have a sql representation" do
-      min.to_sql.should eq <<-SQL.gsub(/^ {6}/, '')
+  it 'min should have a sql representation' do
+    expect(min.to_sql).to eq <<-SQL.gsub(/^ {6}/, '')
       CREATE AGGREGATE min(integer) (
         SFUNC = int4smaller,
         STYPE = int4,
@@ -38,4 +37,4 @@ describe Dumbo::Aggregate do
       SQL
   end
 
-end
+end

data/spec/cast_spec.rb

@@ -1,20 +1,20 @@
 require 'spec_helper'
 describe Dumbo::Cast do
   let(:cast) do
-    oid = sql("SELECT ca.oid
+    oid = query("SELECT ca.oid
               FROM pg_cast ca
               JOIN pg_type st ON st.oid=castsource
               JOIN pg_type tt ON tt.oid=casttarget
               WHERE  format_type(st.oid,NULL) = 'bigint'
-                AND format_type(tt.oid,tt.typtypmod) = 'integer';",'oid').first
+                AND format_type(tt.oid,tt.typtypmod) = 'integer';").first['oid']
     Dumbo::Cast.new(oid)
   end
 
-  it "should have a sql representation" do
-      cast.to_sql.should eq <<-SQL.gsub(/^ {6}/, '')
+  it 'should have a sql representation' do
+      expect(cast.to_sql).to eq <<-SQL.gsub(/^ {6}/, '')
       CREATE CAST (bigint AS integer)
       WITH FUNCTION int4(bigint)
       AS ASSIGNMENT;
       SQL
     end
-end
+end

data/spec/{Makefile → dumbo_sample/Makefile}

@@ -2,5 +2,9 @@
 EXTENSION = dumbo_sample
 PG_CONFIG ?= pg_config
 DATA = $(wildcard *--*.sql)
+
+MODULE_big = dumbo_sample
+OBJS = src/dumbo_sample.o
+
 PGXS := $(shell $(PG_CONFIG) --pgxs)
 include $(PGXS)

data/spec/dumbo_sample/dumbo_sample--0.0.3.sql

@@ -0,0 +1,7 @@
+-- Testing Composite, Range, Enum Types handling.
+
+CREATE TYPE elephant_composite AS (weight integer, name text);
+
+CREATE TYPE elephant_range AS RANGE (subtype = float8, subtype_diff = float8mi);
+
+CREATE TYPE elephant_enum AS ENUM ('infant', 'child', 'adult');

data/spec/dumbo_sample/dumbo_sample--0.0.4.sql

@@ -0,0 +1,13 @@
+-- Testing Base Types handling.
+CREATE TYPE elephant_base;
+
+CREATE FUNCTION elephant_in(cstring) RETURNS elephant_base AS
+'$libdir/dumbo_sample' LANGUAGE C;
+
+CREATE FUNCTION elephant_out(elephant_base) RETURNS cstring AS
+'$libdir/dumbo_sample' LANGUAGE C;
+
+CREATE TYPE elephant_base (
+  INPUT  = elephant_in,
+  OUTPUT = elephant_out
+);

data/spec/dumbo_sample/src/dumbo_sample.c

@@ -0,0 +1,13 @@
+#include "dumbo_sample.h"
+
+Datum elephant_in(PG_FUNCTION_ARGS)
+{
+  int *result = palloc0(sizeof(int));
+  PG_RETURN_POINTER(result);
+}
+
+Datum elephant_out(PG_FUNCTION_ARGS)
+{
+  char *result = palloc0(sizeof(char));
+  PG_RETURN_POINTER(result);
+}

data/spec/dumbo_sample/src/dumbo_sample.h

@@ -0,0 +1,17 @@
+#ifndef _DUMBO_SAMPLE_H
+#define _DUMBO_SAMPLE_H
+
+#include "postgres.h"
+#include "fmgr.h"
+
+#ifdef PG_MODULE_MAGIC
+PG_MODULE_MAGIC;
+#endif
+
+PG_FUNCTION_INFO_V1(elephant_in);
+PG_FUNCTION_INFO_V1(elephant_out);
+
+Datum elephant_in(PG_FUNCTION_ARGS);
+Datum elephant_out(PG_FUNCTION_ARGS);
+
+#endif

data/spec/extension_migrator_spec.rb

@@ -1,15 +1,16 @@
+require 'spec_helper'
+
 describe Dumbo::ExtensionMigrator do
-  before(:all) do
-    system('cd spec && make clean && make && make install')
-  end
-  after (:all) do
-    system('cd spec && make clean && make uninstall')
+  around(:each) do |example|
+    install_testing_extension
+    example.run
+    uninstall_testing_extension
   end
 
-  let(:migrator){Dumbo::ExtensionMigrator.new('dumbo_sample','0.0.1','0.0.2')}
+  let(:migrator) { Dumbo::ExtensionMigrator.new('dumbo_sample', '0.0.1', '0.0.2') }
 
-  it "should provide upgrade sql" do
-    migrator.upgrade.should eq <<-SQL.gsub(/^ {4}/, '')
+  it 'should provide upgrade sql' do
+    expect(migrator.upgrade).to eq <<-SQL.gsub(/^ {4}/, '')
     ----functions----
     CREATE OR REPLACE FUNCTION foo(integer)
      RETURNS integer
@@ -23,8 +24,8 @@ describe Dumbo::ExtensionMigrator do
     SQL
   end
 
-  it "should provide downgrade sql" do
-    migrator.downgrade.should eq <<-SQL.gsub(/^ {4}/, '')
+  it 'should provide downgrade sql' do
+    expect(migrator.downgrade).to eq <<-SQL.gsub(/^ {4}/, '')
     ----functions----
     CREATE OR REPLACE FUNCTION foo(integer)
      RETURNS integer
@@ -37,4 +38,4 @@ describe Dumbo::ExtensionMigrator do
     $function$
     SQL
   end
-end
+end

data/spec/extension_spec.rb

@@ -1,19 +1,48 @@
 require 'spec_helper'
+include ExtensionHelper
 describe Dumbo::Extension do
-  let(:extension){Dumbo::Extension.new('hstore','1.1')}
-  before(:all) do
-    Dumbo::Extension.new('hstore','1.1').install
-  end
+  describe 'extension setup' do
+    let(:extension) { described_class.new('dumbo_sample', '0.0.3') }
 
-  it "should return extension obj_id" do
-    extension.obj_id.should ~ /\d+/
-  end
+    around(:each) do |example|
+      install_testing_extension
+      extension.create
+      example.run
+      uninstall_testing_extension
+    end
+
+    it 'should return extension obj_id' do
+      expect(extension.obj_id).to match /\d+/
+    end
+
+    it 'should return a list of objects' do
+      expect(extension.objects.size).to be 5
+    end
+
+    describe 'handling types' do
+      let(:names) { %w(elephant_composite elephant_range elephant_enum) }
 
-  it 'should return a list of objects' do
-    extension.objects.size.should eq 86
+      let(:classes) { [Dumbo::EnumType, Dumbo::CompositeType, Dumbo::RangeType] }
+
+      subject { extension.types }
+
+      it { expect(subject.map(&:class)).to match_array classes }
+      it { expect(subject.map(&:name)).to match_array names }
+    end
   end
 
-  it 'should return a list of types' do
-    extension.types.select{|t| t.name == 'hstore'}.should_not be_empty
+  describe '#versions' do
+    let(:releases) do
+      ['ext--abc.sql', 'ext--0.10.7.sql', 'ext--0.11.0.sql',
+       'ext--1.0.0.sql', 'ext--0.12.sql', 'ext--0.10.5.sql']
+    end
+
+    before do
+      expect_any_instance_of(described_class).to receive(:releases){releases}
+    end
+
+    subject { described_class.new.versions.map(&:to_s) }
+
+    it { is_expected.to match_array ['0.10.5', '0.10.7', '0.11.0', '0.12', '1.0.0'] }
   end
-end
+end

data/spec/extension_version_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+describe Dumbo::ExtensionVersion do
+  context 'handling full version levels' do
+    let(:version) { described_class.new(0, 1, 11) }
+
+    it { expect(version.to_s).to eq '0.1.11' }
+
+    it { expect(version.bump(:patch).to_s).to eq '0.1.12' }
+    it { expect(version.bump(:minor).to_s).to eq '0.2.0' }
+    it { expect(version.bump(:major).to_s).to eq '1.0.0' }
+
+    it { expect(version).to be < version.bump(:patch) }
+
+    it { expect(version.bump(:patch)).to be < version.bump(:minor) }
+    it { expect(version.bump(:patch)).to be < version.bump(:major) }
+    it { expect(version.bump(:minor)).to be < version.bump(:major) }
+  end
+
+  context 'handling incomplete version levels' do
+    let(:version) { described_class.new(0, 1) }
+
+    it { expect(version.to_s).to eq '0.1'  }
+
+    it { expect(version.bump(:patch).to_s).to eq '0.1.1' }
+    it { expect(version.bump(:minor).to_s).to eq '0.2.0' }
+  end
+end

data/spec/operator_spec.rb

@@ -1,12 +1,12 @@
 require 'spec_helper'
 describe Dumbo::Operator do
   let(:operator) do
-    oid = sql("SELECT oid FROM pg_operator WHERE oprname = '&&' AND format_type(oprleft,NULL) = 'box' AND format_type(oprright,NULL) ='box'",'oid').first
+    oid = query("SELECT oid FROM pg_operator WHERE oprname = '&&' AND format_type(oprleft,NULL) = 'box' AND format_type(oprright,NULL) ='box'").first['oid']
     Dumbo::Operator.new(oid).get
   end
 
-  it "should have a sql representation" do
-    operator.to_sql.should eq <<-SQL.gsub(/^ {4}/, '')
+  it 'should have a sql representation' do
+    expect(operator.to_sql).to eq <<-SQL.gsub(/^ {4}/, '')
     CREATE OPERATOR && (
       PROCEDURE = box_overlap,
       LEFTARG = box,
@@ -19,11 +19,11 @@ describe Dumbo::Operator do
   end
 
   it 'should have a uniq identfier' do
-    operator.identify.should eq ['&&', 'box', 'box']
+    expect(operator.identify).to eq ['&&', 'box', 'box']
   end
 
   it 'should have upgrade sql' do
-    operator.upgrade(nil).should eq <<-SQL.gsub(/^ {4}/, '')
+    expect(operator.upgrade(nil)).to eq <<-SQL.gsub(/^ {4}/, '')
     CREATE OPERATOR && (
       PROCEDURE = box_overlap,
       LEFTARG = box,
@@ -36,7 +36,6 @@ describe Dumbo::Operator do
   end
 
   it 'should have downgrade sql' do
-    operator.downgrade(nil).should eq "DROP OPERATOR &&;"
+    expect(operator.downgrade(nil)).to eq 'DROP OPERATOR &&;'
   end
 end
-

data/spec/spec_helper.rb

@@ -1,28 +1,34 @@
 require 'rubygems'
-require 'factory_girl'
+require 'dumbo/test'
 
 ENV['DUMBO_ENV']  ||= 'test'
 require File.expand_path('../../config/boot', __FILE__)
 
+require 'dumbo/test/silence_unknown_oid'
+
 ActiveRecord::Base.logger.level = 0 if ActiveRecord::Base.logger
 
-Dir.glob("spec/support/**/*.rb").each { |f| require f }
+Dir.glob('spec/support/**/*.rb').each { |f| require f }
 
 RSpec.configure do |config|
   config.fail_fast                                        = false
-  config.order                                            = "random"
-  config.treat_symbols_as_metadata_keys_with_true_values  = true
-  config.include FactoryGirl::Syntax::Methods
+  config.order                                            = 'random'
   config.filter_run focus: true
   config.run_all_when_everything_filtered                 = true
+  config.expect_with :rspec do |c|
+    c.syntax = [:should, :expect]
+  end
 
   # wrap test in transactions
   config.around(:each) do |example|
-     ActiveRecord::Base.transaction do
+    ActiveRecord::Base.transaction do
       example.run
-      raise ActiveRecord::Rollback
-     end
+      fail ActiveRecord::Rollback
+    end
   end
 
-  config.include(SqlHelper)
+  config.include(Dumbo::Test::Helper)
+  config.include(Dumbo::Matchers)
 end
+
+require 'dumbo/test/regression_helper' if ENV['DUMBO_REGRESSION']

data/spec/support/extension_helper.rb

@@ -0,0 +1,31 @@
+module ExtensionHelper
+  def install_testing_extension
+    system <<-CMD
+      (
+        mkdir -p #{spec_root}/dumbo_sample_runtime && \
+        cp -R #{spec_root}/dumbo_sample/ #{spec_root}/dumbo_sample_runtime
+        cd #{spec_root}/dumbo_sample_runtime && \
+        make clean && \
+        make && \
+        make install
+      ) 1> /dev/null
+    CMD
+  end
+
+  def uninstall_testing_extension
+    system <<-CMD
+      (
+        cd #{spec_root}/dumbo_sample_runtime && \
+        make clean && \
+        make uninstall && \
+        rm -rf #{spec_root}/dumbo_sample_runtime
+      ) 1> /dev/null
+    CMD
+  end
+
+  private
+
+  def spec_root
+    File.join(File.dirname(__FILE__), '..')
+  end
+end

data/spec/support/silence_unknown_oid.rb

@@ -0,0 +1,12 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class PostgreSQLAdapter
+      module DatabaseStatements
+        def warn(msg)
+          return if msg =~ /^unknown OID/
+          super
+        end
+      end
+    end
+  end
+end

data/spec/type_spec.rb

@@ -1,64 +1,76 @@
 require 'spec_helper'
+
 describe Dumbo::Type do
+  around(:each) do |example|
+    install_testing_extension
+    extension.create
+    example.run
+    uninstall_testing_extension
+  end
+
+  let(:version) { '0.0.3' }
+
+  let(:extension) { Dumbo::Extension.new('dumbo_sample', version) }
+
+  let(:type) do
+    oid = query("SELECT oid FROM pg_type WHERE typname = '#{type_name}'").first['oid']
+    Dumbo::Type.new(oid).get
+  end
+
+  shared_examples_for 'identifiable' do
+    subject { type.identify }
+
+    it { should eq [type_name] }
+  end
+
   describe 'Base Type' do
-    let(:type) do
-      extension = Dumbo::Extension.new('hstore','1.1')
-      extension.install
-      extension.types.select{|t| t.name =='hstore'}.first
-    end
-    it "should have a sql representation" do
-      type.to_sql.should eq <<-SQL.gsub(/^ {6}/, '')
-      CREATE TYPE hstore(
-        INPUT=hstore_in,
-        OUTPUT=hstore_out,
-        RECEIVE=hstore_recv,
-        SEND=hstore_send,
+    let(:version) { '0.0.4' }
+
+    let(:type_name) { 'elephant_base' }
+
+    let(:type) { extension.types.select { |t| t.name == type_name }.first }
+
+    it 'should have a sql representation' do
+      expect(type.to_sql).to eq <<-SQL.gsub(/^ {6}/, '')
+      CREATE TYPE elephant_base(
+        INPUT=elephant_in,
+        OUTPUT=elephant_out,
+        RECEIVE=-,
+        SEND=-,
         ANALYZE=-,
         CATEGORY='U',
         DEFAULT='',
         INTERNALLENGTH=-1,
         ALIGNMENT=int,
-        STORAGE=EXTENDED
+        STORAGE=PLAIN
       );
       SQL
     end
 
-    it 'should have a uniq identfier' do
-      type.identify.should eq ['hstore']
-    end
+    it_should_behave_like 'identifiable'
   end
 
   describe 'Composite Type' do
-    let(:type) do
-      sql "CREATE TYPE compfoo AS (f1 int, f2 text);"
-      oid = sql("SELECT oid FROM pg_type where typname = 'compfoo'",'oid').first
-      Dumbo::Type.new(oid).get
-    end
+    let(:type_name) { 'elephant_composite' }
 
-    it "should have a sql representation" do
-      type.to_sql.should eq <<-SQL.gsub(/^ {6}/, '')
-      CREATE TYPE compfoo AS (
-        f1 integer,
-        f2 text
+    it 'should have a sql representation' do
+      expect(type.to_sql).to eq <<-SQL.gsub(/^ {6}/, '')
+      CREATE TYPE elephant_composite AS (
+        weight integer,
+        name text
       );
       SQL
     end
 
-    it 'should have a uniq identfier' do
-      type.identify.should eq ['compfoo']
-    end
+    it_should_behave_like 'identifiable'
   end
 
   describe 'Range Type' do
-    let(:type) do
-      sql "CREATE TYPE float8_range AS RANGE (subtype = float8, subtype_diff = float8mi);"
-      oid = sql("SELECT oid FROM pg_type where typname = 'float8_range'",'oid').first
-      Dumbo::Type.new(oid).get
-    end
+    let(:type_name) { 'elephant_range' }
 
-    it "should have a sql representation" do
-      type.to_sql.should eq <<-SQL.gsub(/^ {6}/, '')
-      CREATE TYPE float8_range AS RANGE (
+    it 'should have a sql representation' do
+      expect(type.to_sql).to eq <<-SQL.gsub(/^ {6}/, '')
+      CREATE TYPE elephant_range AS RANGE (
         SUBTYPE=float8,
         SUBTYPE_OPCLASS=float8_ops,
         SUBTYPE_DIFF=float8mi
@@ -66,30 +78,22 @@ describe Dumbo::Type do
       SQL
     end
 
-    it 'should have a uniq identfier' do
-      type.identify.should eq ['float8_range']
-    end
+    it_should_behave_like 'identifiable'
   end
 
   describe 'Enum Type' do
-    let(:type) do
-      sql "CREATE TYPE bug_status AS ENUM ('new', 'open', 'closed');"
-      oid = sql("SELECT oid FROM pg_type where typname = 'bug_status'",'oid').first
-      Dumbo::Type.new(oid).get
-    end
+    let(:type_name) { 'elephant_enum' }
 
-    it "should have a sql representation" do
-      type.to_sql.should eq <<-SQL.gsub(/^ {6}/, '')
-      CREATE TYPE bug_status AS ENUM (
-        'new',
-        'open',
-        'closed'
+    it 'should have a sql representation' do
+      expect(type.to_sql).to eq <<-SQL.gsub(/^ {6}/, '')
+      CREATE TYPE elephant_enum AS ENUM (
+        'infant',
+        'child',
+        'adult'
       );
       SQL
     end
 
-    it 'should have a uniq identfier' do
-      type.identify.should eq ['bug_status']
-    end
+    it_should_behave_like 'identifiable'
   end
-end
+end