alf-sequel 0.13.0

data/spec/compiler/test_project.rb

@@ -0,0 +1,64 @@
+require 'compiler_helper'
+module Alf
+  module Sequel
+    describe Compiler, "project" do
+
+      subject{ compile(expr) }
+
+      context 'when the operand is fully compilable' do
+        let(:expr){ project(suppliers, [:sid, :name]) }
+
+        specify{
+          subject.sql.should eq("SELECT `t1`.`sid`, `t1`.`name` FROM `suppliers` AS 't1'")
+        }
+      end
+
+      context 'when the operand is fully compilable (distinct needed)' do
+        let(:expr){ project(suppliers, [:city]) }
+
+        specify{
+          subject.sql.should eq("SELECT DISTINCT `t1`.`city` FROM `suppliers` AS 't1'")
+        }
+      end
+
+      context 'when the operand is a restriction on a key part' do
+        let(:expr){ project(restrict(supplies, Predicate.eq(:sid, 1)), [:pid]) }
+
+        specify{
+          subject.sql.should eq("SELECT `t1`.`pid` FROM `supplies` AS 't1' WHERE (`t1`.`sid` = 1)")
+        }
+      end
+
+      context 'when the operand is a restriction on the key' do
+        let(:expr){ project(restrict(suppliers, Predicate.eq(:sid, 1)), [:sid]) }
+
+        specify{
+          subject.sql.should eq("SELECT `t1`.`sid` FROM `suppliers` AS 't1' WHERE (`t1`.`sid` = 1)")
+        }
+      end
+
+      context 'when the operand is fully compilable (allbut, distinct)' do
+        let(:expr){ project(suppliers, [:sid, :name, :status], :allbut => true) }
+
+        specify{
+          subject.sql.should eq("SELECT DISTINCT `t1`.`city` FROM `suppliers` AS 't1'")
+        }
+      end
+
+      context 'when the operand is a renaming' do
+        let(:expr){ project(rename(suppliers, :sid => :supplier_id), [:supplier_id]) }
+
+        specify{
+          subject.sql.should eq("SELECT `t2`.`supplier_id` AS 'supplier_id' FROM (SELECT `t1`.`sid` AS 'supplier_id', `t1`.`name` AS 'name', `t1`.`status` AS 'status', `t1`.`city` AS 'city' FROM `suppliers` AS 't1') AS 't2'")
+        }
+      end
+
+      context 'when the operand is not compilable' do
+        let(:expr){ project(an_operand, [:sid, :name]) }
+
+        it{ should be_a(Engine::Cog) }
+      end
+
+    end
+  end
+end

data/spec/compiler/test_rename.rb

@@ -0,0 +1,26 @@
+require 'compiler_helper'
+module Alf
+  module Sequel
+    describe Compiler, "rename" do
+
+      subject{ compile(expr) }
+
+      context 'when the operand is fully compilable' do
+        let(:expr){ rename(suppliers, :sid => :id) }
+
+        specify{
+          subject.sql.should eq("SELECT * FROM (SELECT `t1`.`sid` AS 'id', `t1`.`name` AS 'name', `t1`.`status` AS 'status', `t1`.`city` AS 'city' FROM `suppliers` AS 't1') AS 't2'")
+        }
+      end
+
+      context 'when the operand is another renaming' do
+        let(:expr){ rename(rename(suppliers, :sid => :id), :id => :foo) }
+
+        specify{
+          subject.sql.should eq("SELECT * FROM (SELECT `t2`.`id` AS 'foo', `t2`.`name` AS 'name', `t2`.`status` AS 'status', `t2`.`city` AS 'city' FROM (SELECT `t1`.`sid` AS 'id', `t1`.`name` AS 'name', `t1`.`status` AS 'status', `t1`.`city` AS 'city' FROM `suppliers` AS 't1') AS 't2') AS 't3'")
+        }
+      end
+
+    end
+  end
+end

data/spec/compiler/test_restrict.rb

@@ -0,0 +1,48 @@
+require 'compiler_helper'
+module Alf
+  module Sequel
+    describe Compiler, "restrict" do
+
+      subject{ compile(expr) }
+
+      context 'with a native predicate' do
+        let(:expr){ restrict(suppliers, proc{ status > 20 }) }
+      
+        it{ should be_a(Engine::Filter) }
+      end
+      
+      context 'when the operand is fully compilable' do
+        let(:expr){ restrict(suppliers, :name => "Jones") }
+
+        specify{
+          subject.sql.should eq("SELECT * FROM `suppliers` AS 't1' WHERE (`t1`.`name` = 'Jones')")
+        }
+      end
+
+      context 'when the operand is a IN (values)' do
+        let(:expr){ restrict(suppliers, Predicate.in(:city, ["London", "Paris"])) }
+
+        specify{
+          subject.sql.should eq("SELECT * FROM `suppliers` AS 't1' WHERE (`t1`.`city` IN ('London', 'Paris'))")
+        }
+      end
+
+      context 'when the operand is a NOT IN (values)' do
+        let(:expr){ restrict(suppliers, !Predicate.in(:city, ["London", "Paris"])) }
+
+        specify{
+          subject.sql.should eq("SELECT * FROM `suppliers` AS 't1' WHERE (`t1`.`city` NOT IN ('London', 'Paris'))")
+        }
+      end
+
+      context 'when the operand is a renaming' do
+        let(:expr){ restrict(rename(suppliers, :name => :sname), :sname => "Jones") }
+
+        specify{
+          subject.sql.should eq("SELECT * FROM (SELECT `t1`.`name` AS 'sname', `t1`.`sid` AS 'sid', `t1`.`status` AS 'status', `t1`.`city` AS 'city' FROM `suppliers` AS 't1') AS 't2' WHERE (`t2`.`sname` = 'Jones')")
+        }
+      end
+
+    end
+  end
+end

data/spec/compiler/test_sort.rb

@@ -0,0 +1,18 @@
+require 'compiler_helper'
+module Alf
+  module Sequel
+    describe Compiler, "sort" do
+
+      subject{ compile(expr) }
+
+      context 'when the operand is fully compilable' do
+        let(:expr){ sort(suppliers, [ [:name, :asc], [:status, :desc] ]) }
+
+        specify{
+          subject.sql.should eq("SELECT * FROM `suppliers` AS 't1' ORDER BY `t1`.`name` ASC, `t1`.`status` DESC")
+        }
+      end
+
+    end
+  end
+end

data/spec/compiler/test_union.rb

@@ -0,0 +1,18 @@
+require 'compiler_helper'
+module Alf
+  module Sequel
+    describe Compiler, "union" do
+
+      subject{ compile(expr) }
+
+      context 'when the operand is fully compilable' do
+        let(:expr){ union(suppliers, supplies) }
+
+        specify do
+          subject.sql.should eq("SELECT * FROM (SELECT * FROM `suppliers` AS 't1' UNION SELECT * FROM `supplies` AS 't2') AS 't3'")
+        end
+      end
+
+    end
+  end
+end

data/spec/compiler_helper.rb

@@ -0,0 +1,34 @@
+require_relative 'spec_helper'
+
+module CompilerHelpers
+  include Alf::Lang::Functional
+
+  def suppliers
+    Alf::Algebra.named_operand(:suppliers, sap)
+  end
+
+  def supplies
+    Alf::Algebra.named_operand(:supplies, sap)
+  end
+
+  def parts
+    Alf::Algebra.named_operand(:parts, sap)
+  end
+
+  def _context
+    sap
+  end
+
+  def an_operand
+    Alf::Algebra::Operand::Fake.new(sap)
+  end
+
+  def compile(expr)
+    Alf::Sequel::Compiler.new.call(expr)
+  end
+
+end
+
+RSpec.configure do |c|
+  c.include CompilerHelpers
+end

data/spec/connection/test_connection_uri.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+module Alf
+  module Sequel
+    describe Connection, 'connection_uri' do
+
+      subject{ conn.connection_uri(with_password) }
+
+      let(:with_password){ false }
+
+      context 'when build with an uri' do
+        let(:conn){ Connection.new("somewhere/to/db.sqlite3") }
+
+        it{ should eq("somewhere/to/db.sqlite3") }
+      end
+
+      context 'when build with no host on sqlite' do
+        let(:conn){ Connection.new({:adapter => "sqlite", :database => "sap.db"}) }
+
+        it{ should eq("sqlite://sap.db") }
+      end
+
+      context 'when build with no host on postgres' do
+        let(:conn){ Connection.new({:adapter => "postgres", :database => "sap"}) }
+
+        it{ should eq("postgres://localhost/sap") }
+      end
+
+      context 'when build with a host but no port' do
+        let(:conn){ Connection.new({:adapter => "postgres", :host => "athena", :database => "sap"}) }
+
+        it{ should eq("postgres://athena/sap") }
+      end
+
+      context 'when build with a host and a no port' do
+        let(:conn){ Connection.new({:adapter => "postgres", :host => "athena", :port => 1234, :database => "sap"}) }
+
+        it{ should eq("postgres://athena:1234/sap") }
+      end
+
+      context 'when build with a user/pass and with_password=false' do
+        let(:conn){ Connection.new({:adapter => "postgres", :host => "athena", :user => "buly", :password => "pass", :database => "sap"}) }
+
+        it{ should eq("postgres://buly@athena/sap") }
+      end
+
+      context 'when build with a user/pass and with_password=true' do
+        let(:conn){ Connection.new({:adapter => "postgres", :host => "athena", :user => "buly", :password => "pass", :database => "sap"}) }
+        let(:with_password){ true }
+
+        it{ should eq("postgres://buly:pass@athena/sap") }
+      end
+    end
+  end
+end

data/spec/connection/test_delete.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+module Alf
+  module Sequel
+    describe Connection, 'delete' do
+
+      let(:conn){ sap_memory }
+
+      subject{ conn.delete(:suppliers, Predicate.tautology) }
+
+      it 'returns a UnitOfWork::Delete' do
+        subject.should be_a(UnitOfWork::Delete)
+      end
+
+      it 'is ran' do
+        subject.should be_ran
+      end
+
+    end
+  end
+end

data/spec/connection/test_heading.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+module Alf
+  module Sequel
+    describe Connection, 'heading' do
+
+      subject{ sap.heading(:suppliers) }
+
+      let(:expected){
+        Heading[:sid => Integer, :name => String, :status => Integer, :city => String]
+      }
+
+      it{ should eq(expected) }
+
+    end
+  end
+end

data/spec/connection/test_insert.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+module Alf
+  module Sequel
+    describe Connection, 'insert' do
+
+      let(:conn){ sap_memory }
+
+      subject{ conn.insert(:suppliers, suppliers) }
+
+      let(:suppliers){[
+        {sid: 10, name: "Marcus", status: 20, city: "Ouagadougou"}
+      ]}
+
+      it 'returns a UnitOfWork::Insert' do
+        subject.should be_a(UnitOfWork::Insert)
+      end
+
+      it 'is ran' do
+        subject.should be_ran
+      end
+
+    end
+  end
+end

data/spec/connection/test_keys.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+module Alf
+  module Sequel
+    describe Connection, 'keys' do
+
+      context "when only a primary key" do
+        subject{ sap.keys(:parts) }
+
+        let(:expected){ Keys[ [:pid] ] }
+
+        it{ should eq(expected) }
+      end
+
+      context "when both primary key and unique index" do
+        subject{ sap.keys(:suppliers) }
+
+        let(:expected){ Keys[ [:sid], [:name] ] }
+
+        it{ should eq(expected) }
+      end
+
+    end
+  end
+end

data/spec/connection/test_lock.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+module Alf
+  module Sequel
+    describe Connection, 'lock' do
+
+      subject{ sap.lock(:suppliers, :exclusive){ @seen = true } }
+
+      it 'yields the block' do
+        subject
+        @seen.should be_true
+      end
+
+    end
+  end
+end

data/spec/connection/test_ping.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+module Alf
+  module Sequel
+    describe Connection, "ping" do
+
+      it "returns true on a file" do
+        Connection.new("#{sequel_database_path}").ping.should be_true
+      end
+
+      it "returns true on an uri" do
+        Connection.new(sequel_database_uri).ping.should be_true
+      end
+
+      it "returns true on a Path" do
+        Connection.new(sequel_database_path).ping.should be_true
+      end
+
+      it "raises on non existing" do
+        lambda {
+          Connection.new("postgres://non-existing.sqlite3").ping
+        }.should raise_error
+      end
+
+    end
+  end
+end

data/spec/connection/test_relvar.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+module Alf
+  module Sequel
+    describe Connection, 'relvar' do
+
+      it "should serve relvars" do
+        sap.relvar(:suppliers).should be_a(Alf::Relvar)
+      end
+
+      it "should be the correct relation" do
+        sap.relvar(:suppliers).value.size.should eq(5)
+      end
+
+    end
+  end
+end

data/spec/connection/test_update.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+module Alf
+  module Sequel
+    describe Connection, 'update' do
+
+      let(:conn){ sap_memory }
+
+      subject{ conn.update(:suppliers, {status: 10}, Predicate.tautology) }
+
+      it 'returns a UnitOfWork::Update' do
+        subject.should be_a(UnitOfWork::Update)
+      end
+
+      it 'is ran' do
+        subject.should be_ran
+      end
+
+    end
+  end
+end

data/spec/fixtures/sap.rb

@@ -0,0 +1,43 @@
+class SAP
+
+  def self.create!(sequel_db)
+    sequel_db = ::Sequel.connect(sequel_db) unless sequel_db.is_a?(::Sequel::Database)
+    sequel_db.tap do |db|
+      db.create_table(:suppliers) do
+        primary_key :sid
+        String :name
+        Integer :status
+        String :city
+        index :name, :unique => true
+      end
+      db.create_table(:parts) do
+        primary_key :pid
+        String :name
+        String :color
+        Float :weight
+        String :city
+      end
+      db.create_table(:supplies) do
+        Integer :sid
+        Integer :pid
+        Integer :qty
+        primary_key [:sid, :pid]
+      end
+    end
+    Alf.connect(sequel_db) do |alf_db|
+      ex = Alf.examples
+      alf_db.relvar(:suppliers).affect ex.query{
+        (extend suppliers, :sid => lambda{ (sid.match /\d+/)[0].to_i })
+      }
+      alf_db.relvar(:parts).affect ex.query{
+        (extend parts, :pid => lambda{ (pid.match /\d+/)[0].to_i })
+      }
+      alf_db.relvar(:supplies).affect ex.query{
+        (extend supplies, :sid => lambda{ (sid.match /\d+/)[0].to_i },
+                          :pid => lambda{ (pid.match /\d+/)[0].to_i })
+      }
+    end
+    sequel_db
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,35 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'alf-sequel'
+require "rspec"
+require 'path'
+require_relative 'fixtures/sap.rb'
+
+module Helpers
+
+  def sequel_database_path
+    Path.dir/'alf.db'
+  end
+
+  def sequel_database_uri
+    "#{Alf::Sequel::Adapter.sqlite_protocol}://#{sequel_database_path}"
+  end
+
+  def sequel_database_memory
+    "#{Alf::Sequel::Adapter.sqlite_protocol}::memory:"
+  end
+
+  def sap
+    @sap ||= Alf.connect Path.relative("fixtures/sap.db")
+  end
+
+  def sap_memory
+    Alf.connect(SAP.create!(sequel_database_memory), schema_cache: false)
+  end
+
+end
+
+RSpec.configure do |c|
+  c.include Helpers
+  c.extend  Helpers
+  c.filter_run_excluding :ruby19 => (RUBY_VERSION < "1.9")
+end

data/spec/test_assumptions.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+describe "assumptions" do
+
+  context 'sqlite://memory' do
+    let(:db1){ ::Sequel.connect(sequel_database_memory) }
+    let(:db2){ ::Sequel.connect(sequel_database_memory) }
+
+    it 'leads to two different databases' do
+      db1.create_table(:blah){ primary_key :id }
+      db2.create_table(:blah){ primary_key :id }
+    end
+  end
+
+end

data/spec/test_sequel.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+module Alf
+  describe Sequel do
+
+    it "should have a version number" do
+      Sequel.const_defined?(:VERSION).should be_true
+    end
+
+  end
+end

data/spec/unit_of_work/atomic/test_run.rb

@@ -0,0 +1,72 @@
+require "spec_helper"
+module Alf
+  module Sequel
+    module UnitOfWork
+      describe Atomic, "run" do
+
+        def build_uow(&bl)
+          Object.new.tap{|uow|
+            uow.extend(Atomic)
+            uow.singleton_class.send(:define_method, :_run, &bl)
+          }
+        end
+
+        subject{ uow.run }
+
+        context 'when the block succeeds' do
+          let(:uow){ build_uow{ true } }
+
+          it 'returns itself' do
+            subject.should be(uow)
+          end
+
+          it 'sets ran? to true' do
+            subject.should be_ran
+          end
+
+          it 'sets failed? to false' do
+            subject.should_not be_failed
+          end
+        end
+
+        context 'when the block fails' do
+          let(:uow){ build_uow{ raise ArgumentError, "failed" } }
+
+          it 'raise the error' do
+            lambda{
+              subject
+            }.should raise_error(ArgumentError, "failed")
+          end
+
+          it 'sets ran? to true' do
+            lambda{ subject }.should raise_error
+            uow.should be_ran
+          end
+
+          it 'sets failed? to false' do
+            lambda{ subject }.should raise_error
+            uow.should be_failed
+          end
+
+          it 'sets failure to the error' do
+            lambda{ subject }.should raise_error
+            uow.failure.should be_a(ArgumentError)
+          end
+        end
+
+        context 'when already ran' do
+          let(:uow){ build_uow{ true } }
+
+          before{ uow.run }
+
+          it 'raises an Alf::IllegalStateError' do
+            lambda{
+              subject
+            }.should raise_error(IllegalStateError, /already ran/)
+          end
+        end
+
+      end
+    end # module UnitOfWork
+  end # module Sequel
+end # module Alf

data/spec/unit_of_work/delete/test_delete.rb

@@ -0,0 +1,39 @@
+require "spec_helper"
+module Alf
+  module Sequel
+    module UnitOfWork
+      describe Delete, "run" do
+
+        let(:conn){ sap_memory.adapter_connection }
+        let(:uow){
+          UnitOfWork::Delete.new(conn, relvar_name, predicate)
+        }
+        subject{ uow.run }
+
+        before do
+          subject.should be(uow)
+        end
+
+        context 'when predicate is a tautology' do
+          let(:relvar_name){ :suppliers }
+          let(:predicate){ Predicate.tautology }
+
+          it 'removes all tuples' do
+            conn.dataset(relvar_name).should be_empty
+          end
+        end
+
+        context 'when predicate is not a tautology' do
+          let(:relvar_name){ :suppliers }
+          let(:predicate){ Predicate.eq(sid: 1) }
+
+          it 'removes only targetted tuples' do
+            conn.dataset(relvar_name).should_not be_empty
+            conn.dataset(relvar_name).where(sid: 1).should be_empty
+          end
+        end
+
+      end
+    end # module UnitOfWork
+  end # module Sequel
+end # module Alf