rom-sql 2.0.0.beta2 → 2.0.0.beta3

data/spec/extensions/postgres/integration_spec.rb

@@ -1,59 +0,0 @@
-RSpec.describe 'PostgreSQL extension', :postgres do
-  include_context 'database setup'
-
-  before do
-    conn.drop_table?(:pg_people)
-    conn.drop_table?(:people)
-
-    conn.create_table :pg_people do
-      primary_key :id
-      String :name
-      column :tags, "text[]"
-    end
-
-    conf.relation(:people) do
-      schema(:pg_people, infer: true)
-    end
-
-    conf.commands(:people) do
-      define(:create)
-      define(:update)
-    end
-  end
-
-  let(:people_relation) { relations[:people] }
-
-  describe 'using arrays' do
-    let(:people) { commands[:people] }
-
-    it 'inserts array values' do
-      people.create.call(name: 'John Doe', tags: ['foo'])
-      expect(people_relation.to_a).to eq([id: 1, name: 'John Doe', tags: ['foo']])
-    end
-
-    it 'inserts empty arrays' do
-      people.create.call(name: 'John Doe', tags: [])
-      expect(people_relation.to_a).to eq([id: 1, name: 'John Doe', tags: []])
-    end
-  end
-
-  describe 'using retrurning' do
-    let(:create_person) { commands[:people].create }
-    let(:update_person) { commands[:people].update }
-    let(:composite_relation) { people_relation >> -> r { r.to_a.map { |x| x.fetch(:name).upcase } } }
-
-    context 'with pipeline' do
-      it 'works with create' do
-        mapped_people = create_person.new(composite_relation).call(name: 'John Doe', tags: ['foo'])
-        expect(mapped_people).to eql(['JOHN DOE'])
-      end
-
-      it 'works with update' do
-        create_person.call(name: 'John Doe', tags: ['foo'])
-
-        mapped_people = update_person.new(composite_relation).call(name: 'Jane Doe')
-        expect(mapped_people).to eql(['JANE DOE'])
-      end
-    end
-  end
-end

data/spec/extensions/postgres/types_spec.rb

@@ -1,252 +0,0 @@
-RSpec.describe 'ROM::SQL::Types' do
-  describe 'ROM::SQL::Types::PG::JSON' do
-    it 'coerces to pg json hash' do
-      input = { foo: 'bar' }
-
-      expect(ROM::SQL::Types::PG::JSON[input]).to eql(Sequel.pg_json(input))
-    end
-
-    it 'coerces to pg json array' do
-      input = [1, 2, 3]
-      output = ROM::SQL::Types::PG::JSON[input]
-
-      expect(output).to be_instance_of(Sequel::Postgres::JSONArray)
-      expect(output.to_a).to eql(input)
-    end
-  end
-
-  describe 'ROM::SQL::Types::PG::Bytea' do
-    it 'coerces strings to Sequel::SQL::Blob' do
-      input = 'sutin'
-      output = ROM::SQL::Types::PG::Bytea[input]
-
-      expect(output).to be_instance_of(Sequel::SQL::Blob)
-      expect(output).to eql('sutin')
-    end
-  end
-
-  describe ROM::SQL::Types::PG::UUID do
-    it 'coerces strings to UUID' do
-      input  = SecureRandom.uuid
-      output = described_class[input]
-
-      expect(output).to be_instance_of(String)
-    end
-  end
-
-  describe ROM::SQL::Types::PG::Array do
-    it 'coerces to pg array' do
-      input  = [1, 2, 3]
-      output = ROM::SQL::Types::PG::Array('integer')[input]
-
-      expect(output).to be_instance_of(Sequel::Postgres::PGArray)
-      expect(output.to_a).to eql(input)
-    end
-
-    it 'accepts any other type of objects' do
-      input  = [nil, 1, 'sutin', :sutin, 1.0, {}].sample
-      output = ROM::SQL::Types::PG::Array('integer')[input]
-
-      expect(output).to be_instance_of(Sequel::Postgres::ArrayOp)
-      expect(output.value).to eql(input)
-    end
-  end
-
-  describe ROM::SQL::Types::PG::JSON do
-    it 'coerces to pg json hash' do
-      input  = { foo: 'bar' }
-      output = described_class[input]
-
-      expect(output).to be_instance_of(Sequel::Postgres::JSONHash)
-      expect(output).to eql(Sequel.pg_json(input))
-    end
-
-    it 'coerces to pg json array' do
-      input  = [1, 2, 3]
-      output = described_class[input]
-
-      expect(output).to be_instance_of(Sequel::Postgres::JSONArray)
-      expect(output.to_a).to eql(input)
-    end
-
-    it 'accepts any other type of objects' do
-      input  = [nil, 1, 'sutin', :sutin, 1.0].sample
-      output = described_class[input]
-
-      expect(output).to be_instance_of(Sequel::Postgres::JSONOp)
-      expect(output.value).to eql(input)
-    end
-  end
-
-  describe ROM::SQL::Types::PG::JSONB do
-    it 'coerces to pg jsonb hash' do
-      input  = { foo: 'bar' }
-      output = described_class[input]
-
-      expect(output).to be_instance_of(Sequel::Postgres::JSONBHash)
-      expect(output).to eql(Sequel.pg_jsonb(input))
-    end
-
-    it 'coerces to pg jsonb array' do
-      input  = [1, 2, 3]
-      output = described_class[input]
-
-      expect(output).to be_instance_of(Sequel::Postgres::JSONBArray)
-      expect(output.to_a).to eql(input)
-    end
-
-    it 'accepts any other type of objects' do
-      input  = [nil, 1, 'sutin', :sutin, 1.0].sample
-      output = described_class[input]
-
-      expect(output).to be_instance_of(Sequel::Postgres::JSONBOp)
-      expect(output.value).to eql(input)
-    end
-  end
-
-  describe ROM::SQL::Types::PG::Money do
-    it 'coerces to pg Money' do
-      input  = BigDecimal.new(1.0, 2)
-      output = described_class[input]
-
-      expect(output).to be_instance_of(BigDecimal)
-    end
-  end
-
-  describe ROM::SQL::Types::PG::IPAddress do
-    it 'converts IPAddr to a string' do
-      expect(described_class[IPAddr.new('127.0.0.1')]).to eql('127.0.0.1')
-    end
-
-    it 'coerces to builtin IPAddr type on read' do
-      expect(described_class.meta[:read]['127.0.0.1']).to eql(IPAddr.new('127.0.0.1'))
-    end
-
-    it 'supports networks' do
-      class_a = described_class.meta[:read]['10.0.0.0/8']
-
-      expect(class_a).to eql(IPAddr.new('10.0.0.0/8'))
-      expect(class_a).to include(IPAddr.new('10.8.8.8'))
-    end
-  end
-
-  describe ROM::SQL::Types::PG::PointT do
-    let(:point) { ROM::SQL::Types::PG::Point.new(7.5, 30.5) }
-
-    it 'serializes a point down to a string' do
-      expect(described_class[point]).to eql('(7.5,30.5)')
-    end
-
-    it 'reads serialized format' do
-      expect(described_class.meta[:read]['(7.5,30.5)']).to eql(point)
-    end
-  end
-
-  describe ROM::SQL::Types::PG::HStore do
-    let(:mapping) { Hash['hot' => 'cold'] }
-    let(:read_type) { described_class.meta[:read] }
-
-    it 'covertss data to Sequel::Postgres::HStore' do
-      expect(described_class[mapping]).to be_a Sequel::Postgres::HStore
-      expect(described_class[mapping]).to eql(Sequel.hstore(hot: :cold))
-    end
-
-    it 'reads Sequel::Postgres::HStore as a Hash object' do
-      expect(read_type[Sequel.hstore(mapping)]).to eql(mapping)
-      expect(read_type[Sequel.hstore(mapping)]).to be_a(Hash)
-    end
-  end
-
-  describe ROM::SQL::Types::PG::LineT do
-    let(:line) { ROM::SQL::Types::PG::Line.new(2.3, 4.9, 3.1415) }
-
-    it 'serializes a line using the {A,B,C} format' do
-      expect(described_class[line]).to eql('{2.3,4.9,3.1415}')
-    end
-
-    it 'reads the {A,B,C} format' do
-      expect(described_class.meta[:read]['{2.3,4.9,3.1415}']).to eql(line)
-    end
-  end
-
-  describe ROM::SQL::Types::PG::CircleT do
-    let(:center) { ROM::SQL::Types::PG::Point.new(7.5, 30.5) }
-    let(:circle) { ROM::SQL::Types::PG::Circle.new(center, 1.2) }
-
-    it 'serializes a circle using the <(x,y),r> format' do
-      expect(described_class[circle]).to eql('<(7.5,30.5),1.2>')
-    end
-
-    it 'reads the <(x,y),r> format' do
-      expect(described_class.meta[:read]['<(7.5,30.5),1.2>']).to eql(circle)
-    end
-  end
-
-  describe ROM::SQL::Types::PG::BoxT do
-    let(:lower_left) { ROM::SQL::Types::PG::Point.new(7.5, 20.5) }
-    let(:upper_right) { ROM::SQL::Types::PG::Point.new(8.5, 30.5) }
-
-    let(:box) { ROM::SQL::Types::PG::Box.new(upper_right, lower_left) }
-
-    it 'serializes a box' do
-      expect(described_class[box]).to eql('((8.5,30.5),(7.5,20.5))')
-    end
-
-    it 'reads serialized format' do
-      expect(described_class.meta[:read]['((8.5,30.5),(7.5,20.5))']).to eql(box)
-    end
-  end
-
-  describe ROM::SQL::Types::PG::LineSegmentT do
-    let(:first) { ROM::SQL::Types::PG::Point.new(8.5, 30.5) }
-    let(:second) { ROM::SQL::Types::PG::Point.new(7.5, 20.5) }
-
-    let(:lseg) { ROM::SQL::Types::PG::LineSegment.new(first, second) }
-
-    it 'serializes a lseg using [ ( x1 , y1 ) , ( x2 , y2 ) ] format' do
-      expect(described_class[lseg]).to eql('[(8.5,30.5),(7.5,20.5)]')
-    end
-
-    it 'reads serialized format' do
-      expect(described_class.meta[:read]['[(8.5,30.5),(7.5,20.5)]']).to eql(lseg)
-    end
-  end
-
-  describe ROM::SQL::Types::PG::PolygonT do
-    let(:first) { ROM::SQL::Types::PG::Point.new(8.5, 30.5) }
-    let(:second) { ROM::SQL::Types::PG::Point.new(7.5, 20.5) }
-    let(:third) { ROM::SQL::Types::PG::Point.new(6.5, 10.5) }
-
-    let(:polygon) { ROM::SQL::Types::PG::Polygon[[first, second, third]] }
-
-    it 'serializes a polygon using ( ( x1 , y1 ) ... ( xn , yn ) ) format' do
-      expect(described_class[polygon]).to eql('((8.5,30.5),(7.5,20.5),(6.5,10.5))')
-    end
-
-    it 'reads serialized format' do
-      expect(described_class.meta[:read]['((8.5,30.5),(7.5,20.5),(6.5,10.5))']).to eql(polygon)
-    end
-  end
-
-  describe ROM::SQL::Types::PG::PathT do
-    let(:first) { ROM::SQL::Types::PG::Point.new(8.5, 30.5) }
-    let(:second) { ROM::SQL::Types::PG::Point.new(7.5, 20.5) }
-    let(:third) { ROM::SQL::Types::PG::Point.new(6.5, 10.5) }
-
-    let(:closed_path) { ROM::SQL::Types::PG::Path.new([first, second, third], :closed) }
-    let(:open_path) { ROM::SQL::Types::PG::Path.new([first, second, third], :open) }
-
-    it 'serializes a closed path using ( ( x1 , y1 ) ... ( xn , yn ) ) format' do
-      expect(described_class[closed_path]).to eql('((8.5,30.5),(7.5,20.5),(6.5,10.5))')
-    end
-
-    it 'serializes an open path' do
-      expect(described_class[open_path]).to eql('[(8.5,30.5),(7.5,20.5),(6.5,10.5)]')
-    end
-
-    it 'reads serialized format' do
-      expect(described_class.meta[:read]['((8.5,30.5),(7.5,20.5),(6.5,10.5))']).to eql(closed_path)
-      expect(described_class.meta[:read]['[(8.5,30.5),(7.5,20.5),(6.5,10.5)]']).to eql(open_path)
-    end
-  end
-end

data/spec/extensions/sqlite/types_spec.rb

@@ -1,11 +0,0 @@
-RSpec.describe 'ROM::SQL::Types' do
-  describe 'ROM::SQL::Types::SQLite::Object' do
-    let(:type) { ROM::SQL::Types::SQLite::Object }
-
-    it 'passes an object of any type' do
-      [Object.new, 1, true, BasicObject.new].each do |obj|
-        expect(type[obj]).to be obj
-      end
-    end
-  end
-end

data/spec/fixtures/migrations/20150403090603_create_carrots.rb

@@ -1,8 +0,0 @@
-ROM::SQL.migration do
-  change do
-    create_table :carrots do
-      primary_key :id
-      String :name
-    end
-  end
-end

data/spec/integration/associations/many_to_many/custom_fks_spec.rb

@@ -1,76 +0,0 @@
-RSpec.describe ROM::SQL::Associations::ManyToMany, '#call' do
-  include_context 'users'
-
-  before do
-    inferrable_relations.concat %i(puzzles puzzle_solvers)
-  end
-
-  subject(:assoc) do
-    relations[:users].associations[:puzzles]
-  end
-
-  let(:puzzles) { relations[:puzzles] }
-  let(:puzzle_solvers) { relations[:puzzle_solvers] }
-
-  with_adapters do
-    before do
-      conn.create_table(:puzzles) do
-        primary_key :id
-        column :text, String, null: false
-      end
-
-      conn.create_table(:puzzle_solvers) do
-        foreign_key :solver_id, :users, null: false
-        foreign_key :puzzle_id, :puzzles, null: false
-        primary_key [:solver_id, :puzzle_id]
-      end
-
-      conf.relation(:puzzles) { schema(infer: true) }
-
-      conf.relation(:puzzle_solvers) do
-        schema(infer: true) do
-          associations do
-            belongs_to :user, foreign_key: :solver_id
-            belongs_to :puzzle
-          end
-        end
-      end
-
-      conf.relation(:users) do
-        schema(infer: true) do
-          associations do
-            has_many :puzzle_solvers
-            has_many :puzzles, through: :puzzle_solvers, foreign_key: :solver_id
-          end
-        end
-      end
-
-      p1_id = relations[:puzzles].insert(text: 'P1')
-      p2_id = relations[:puzzles].insert(text: 'P2')
-      p3_id = relations[:puzzles].insert(text: 'P3')
-
-      relations[:puzzle_solvers].insert(solver_id: joe_id, puzzle_id: p2_id)
-      relations[:puzzle_solvers].insert(solver_id: jane_id, puzzle_id: p2_id)
-
-      relations[:puzzle_solvers].insert(solver_id: joe_id, puzzle_id: p1_id)
-      relations[:puzzle_solvers].insert(solver_id: jane_id, puzzle_id: p3_id)
-    end
-
-    it 'prepares joined relations using custom FK' do
-      relation = assoc.().order(puzzles[:text].qualified, puzzle_solvers[:solver_id].qualified)
-
-      expect(relation.schema.map(&:to_sql_name)).
-        to eql([Sequel.qualify(:puzzles, :id),
-                Sequel.qualify(:puzzles, :text),
-                Sequel.qualify(:puzzle_solvers, :solver_id)])
-
-      expect(relation.to_a).
-        to eql([
-                 { id: 1, solver_id: 2, text: 'P1' },
-                 { id: 2, solver_id: 1, text: 'P2' },
-                 { id: 2, solver_id: 2, text: 'P2' },
-                 { id: 3, solver_id: 1, text: 'P3' }
-               ])
-    end
-  end
-end

data/spec/integration/associations/many_to_many/from_view_spec.rb

@@ -1,88 +0,0 @@
-RSpec.describe ROM::SQL::Associations::ManyToMany, '#call' do
-  include_context 'users'
-
-  before do
-    inferrable_relations.concat %i(puzzles puzzle_solvers)
-  end
-
-  subject(:assoc) do
-    relations[:users].associations[:solved_puzzles]
-  end
-
-  let(:puzzles) { relations[:puzzles] }
-  let(:puzzle_solvers) { relations[:puzzle_solvers] }
-
-  with_adapters do
-    before do
-      conn.create_table(:puzzles) do
-        primary_key :id
-        column :text, String, null: false
-        column :solved, TrueClass, null: false, default: false
-      end
-
-      conn.create_table(:puzzle_solvers) do
-        foreign_key :user_id, :users, null: false
-        foreign_key :puzzle_id, :puzzles, null: false
-        primary_key [:user_id, :puzzle_id]
-      end
-
-      conf.relation(:puzzles) do
-        schema(infer: true)
-
-        view(:solved, schema) do
-          where(solved: true)
-        end
-      end
-
-      conf.relation(:puzzle_solvers) do
-        schema(infer: true) do
-          associations do
-            belongs_to :user
-            belongs_to :puzzle
-          end
-        end
-      end
-
-      conf.relation(:users) do
-        schema(infer: true) do
-          associations do
-            has_many :puzzle_solvers
-            has_many :puzzles, through: :puzzle_solvers
-            has_many :puzzles, through: :puzzle_solvers, as: :solved_puzzles, view: :solved
-          end
-        end
-      end
-
-      p1_id = relations[:puzzles].insert(text: 'P1')
-      p2_id = relations[:puzzles].insert(text: 'P2', solved: true)
-      p3_id = relations[:puzzles].insert(text: 'P3')
-
-      relations[:puzzle_solvers].insert(user_id: joe_id, puzzle_id: p2_id)
-      relations[:puzzle_solvers].insert(user_id: jane_id, puzzle_id: p2_id)
-
-      relations[:puzzle_solvers].insert(user_id: joe_id, puzzle_id: p1_id)
-      relations[:puzzle_solvers].insert(user_id: jane_id, puzzle_id: p3_id)
-    end
-
-    after do
-      conn.drop_table?(:puzzle_solvers)
-      conn.drop_table?(:puzzles)
-    end
-
-    it 'prepares joined relations using custom FK' do
-      relation = assoc.().order(puzzles[:text].qualified, puzzle_solvers[:user_id].qualified)
-
-      expect(relation.schema.map(&:to_sql_name)).
-        to eql([Sequel.qualify(:puzzles, :id),
-                Sequel.qualify(:puzzles, :text),
-                Sequel.qualify(:puzzles, :solved),
-                Sequel.qualify(:puzzle_solvers, :user_id)])
-
-      expect(relation.to_a).
-        to eql([
-                 { id: 2, user_id: 1, solved: db_true, text: 'P2' },
-                 { id: 2, user_id: 2, solved: db_true, text: 'P2' }
-               ])
-    end
-  end
-end