dbagile 0.0.1

data/test/unit/core/repository/has_database_q.spec

@@ -0,0 +1,16 @@
+require File.expand_path('../fixtures', __FILE__)
+describe "DbAgile::Core::Repository#has_database?" do
+
+  let(:repository){ DbAgile::Fixtures::Core::Repository::repository(:test_and_prod) }
+
+  describe("When called with an unexisting database") do
+    subject{ repository.has_database?(:test) }
+    it{ should == true }
+  end
+
+  describe("When called with an missing database") do
+    subject{ repository.has_database?(:nosuchone) }
+    it{ should == false }
+  end
+  
+end

data/test/unit/core/repository/load.spec

@@ -0,0 +1,51 @@
+require File.expand_path('../fixtures', __FILE__)
+describe "DbAgile::Core::Repository::load /" do
+
+  let(:loader){ lambda{ DbAgile::Core::Repository::load(path) } }
+  
+  describe "on a valid repository /" do
+    let(:path){ DbAgile::Fixtures::Core::Repository::repository_path(:test_and_prod) }
+    let(:loaded){ loader.call }
+    
+    it "should not raise any error" do
+      loader.should_not raise_error
+    end
+    
+    it "should return a Repository instance" do
+      loaded.should be_kind_of(DbAgile::Core::Repository)
+    end
+    
+    it "should have a version number" do
+      loaded.version.should_not be_nil
+    end
+    
+  end # valid
+
+  describe "on an unexisting repository /" do
+    let(:path){ DbAgile::Fixtures::Core::Repository::repository_path(:unexisting) }
+    
+    it "should raise an IOError" do
+      loader.should raise_error(IOError)
+    end
+    
+  end # unexisting
+
+  describe "on an invalid repository /" do
+    let(:path){ DbAgile::Fixtures::Core::Repository::repository_path(:invalid) }
+    
+    it "should raise an IOError" do
+      loader.should raise_error(IOError)
+    end
+    
+  end # invalid
+
+  describe "on an corrupted repository /" do
+    let(:path){ DbAgile::Fixtures::Core::Repository::repository_path(:corrupted) }
+    
+    it "should raise a CorruptedRepositoryError" do
+      loader.should raise_error(DbAgile::CorruptedRepositoryError)
+    end
+    
+  end # corrupted
+
+end

data/test/unit/core/repository/to_yaml.spec

@@ -0,0 +1,17 @@
+require File.expand_path('../fixtures', __FILE__)
+describe "DbAgile::Core::Repository#to_yaml /" do
+
+  let(:path){ DbAgile::Fixtures::Core::Repository::repository_path(:test_and_prod) }
+  let(:repo){ DbAgile::Core::Repository::load(path) }
+
+  it "should return a valid yaml string" do 
+    repo.to_yaml.should be_a_valid_yaml_string
+  end
+  
+  it "should be such that a repository could be created" do
+    got = DbAgile::Core::Repository.send(:from_yaml, repo.to_yaml, path)
+    got.should be_kind_of(DbAgile::Core::Repository)
+  end
+
+end
+  

data/test/unit/core/schema/check.spec

@@ -0,0 +1,32 @@
+require File.expand_path('../fixtures', __FILE__)
+describe "DbAgile::Core::Schema checking" do
+  
+  subject{ lambda{ schema.check! } }
+  
+  [:dbagile,
+   :left, :right, 
+   :suppliers_and_parts].each{|k|
+    it "should be ok on #{k}" do
+      schema = DbAgile::Fixtures::Core::Schema::schema(k)
+      lambda{ schema.check! }.should_not raise_error
+    end
+  }
+
+  describe "when called on an invalid schema" do
+    let(:schema){ DbAgile::Fixtures::Core::Schema::schema(:invalid) }
+    specify{ 
+      subject.should raise_error(DbAgile::SchemaSemanticsError) 
+      
+      # each relvar has exactly one error except:
+      #   - VALID, which is valid -> -1
+      #   - EMPTY (no pkey, empty heading) -> +1
+      expected_size =  schema.logical.size - 1 + 1
+      
+      # each index has exactly one error
+      expected_size += schema.physical.indexes.size
+      
+      schema.check!(false).size.should == expected_size
+    }
+  end
+
+end

data/test/unit/core/schema/empty_q.spec

@@ -0,0 +1,18 @@
+require File.expand_path('../fixtures', __FILE__)
+describe "DbAgile::Core::Schema#empty?" do
+
+  it "should not be empty on a non empty schema" do
+    [:left, :right].each{|n|
+      schema = DbAgile::Fixtures::Core::Schema::schema(n)
+      schema.empty?.should be_false
+    }
+  end
+  
+  it "should be empty on a empty schema" do
+    [:empty].each{|n|
+      schema = DbAgile::Fixtures::Core::Schema::schema(n)
+      schema.empty?.should be_true
+    }
+  end
+  
+end

data/test/unit/core/schema/filter.spec

@@ -0,0 +1,42 @@
+require File.expand_path('../fixtures', __FILE__)
+describe "DbAgile::Core::Schema#filter" do
+  
+  let(:schema) { DbAgile::Fixtures::Core::Schema::schema(:suppliers_and_parts) }
+
+  it "should filter correctly through constraint/not constraint separation" do
+    constraints = schema.filter{|k| k.constraint?}
+    others = schema.filter{|k| !k.constraint?}
+    constraints.visit{|o, parent|
+      unless o.composite?
+        o.should be_kind_of(DbAgile::Core::Schema::Logical::Constraint)
+      end
+    }
+    others.visit{|o, parent|
+      unless o.composite?
+        o.should_not be_kind_of(DbAgile::Core::Schema::Logical::Constraint)
+      end
+    }
+    # puts constraints.to_yaml
+    # puts others.to_yaml
+    (constraints + others).look_same_as?(schema).should be_true
+  end
+
+  it "should filter correctly through logical/physical separation" do
+    logical  = schema.filter{|k| k.logical?}
+    physical = schema.filter{|k| k.physical?}
+    logical.visit{|o, parent|
+      unless o.composite?
+        o.logical?.should be_true
+      end
+    }
+    physical.visit{|o, parent|
+      unless o.composite?
+        o.physical?.should be_true
+      end
+    }
+    # puts logical.to_yaml
+    # puts physical.to_yaml
+    (logical + physical).look_same_as?(schema).should be_true
+  end
+  
+end

data/test/unit/core/schema/fixtures/dbagile.yaml

@@ -0,0 +1,7 @@
+--- 
+logical: 
+  DBAGILE_INFO:
+    heading:
+      VERSION: { domain: String, mandatory: true }
+    constraints: 
+      pk: { type: :primary_key, attributes: [ 'VERSION' ] }

data/test/unit/core/schema/fixtures/empty.yaml

@@ -0,0 +1,11 @@
+# This is a comment
+--- 
+logical: 
+  # Here also
+  EMPTY_RELVAR: 
+    heading: {}
+    constraints: {}
+---
+physical:
+  indexes: {}
+  

data/test/unit/core/schema/fixtures/invalid.yaml

@@ -0,0 +1,54 @@
+--- 
+logical: 
+  VALID_WITH_SINGLE_PK:
+    heading: 
+      ID: { domain: Integer, mandatory: true }
+    constraints:
+      pk: { type: primary_key, attributes: [ 'ID' ]}
+  EMPTY: 
+    heading: {}
+    constraints: {}
+  MISSING_PRIMARY_KEY: 
+    heading: 
+      ID: { domain: Integer, mandatory: true }
+  BAD_CANDIDATE_KEY_NOSUCH_ATTRIBUTES: 
+    heading: 
+      ID: { domain: Integer, mandatory: true }
+    constraints: 
+      pk: { type: primary_key, attributes: [ 'NOT_EXISTS' ] }
+  BAD_FOREIGN_KEY_NO_SUCH_REFERENCED_RELVAR: 
+    heading: 
+      ID: { domain: Integer, mandatory: true }
+    constraints: 
+      pk: { type: primary_key, attributes: [ 'ID' ]}
+      fk: { type: foreign_key, attributes: [ 'ID' ], references: 'NO' }
+  BAD_FOREIGN_KEY_NO_SUCH_SOURCE_ATTRIBUTES: 
+    heading: 
+      ID: { domain: Integer, mandatory: true }
+    constraints: 
+      pk: { type: primary_key, attributes: [ 'ID' ]}
+      fk: { type: foreign_key, attributes: [ 'NONE' ], references: 'VALID_WITH_SINGLE_PK' }
+  BAD_FOREIGN_KEY_NO_SUCH_TARGET_KEY: 
+    heading: 
+      ID: { domain: Integer, mandatory: true }
+    constraints: 
+      pk: { type: primary_key, attributes: [ 'ID' ]}
+      fk: { type: foreign_key, attributes: [ 'ID' ], references: 'VALID_WITH_SINGLE_PK', key: no_suck_pk }
+  BAD_FOREIGN_KEY_TARGET_KEY_SIZE_MISMATCH: 
+    heading: 
+      ID:   { domain: Integer, mandatory: true }
+      NAME: { domain: String, mandatory: true }
+    constraints: 
+      pk: { type: primary_key, attributes: [ 'ID' ]}
+      fk: { type: foreign_key, attributes: [ 'ID', 'NAME' ], references: 'VALID_WITH_SINGLE_PK' }
+  BAD_FOREIGN_KEY_TARGET_KEY_MISMATCH: 
+    heading: 
+      ID: { domain: String, mandatory: true }
+    constraints: 
+      pk: { type: primary_key, attributes: [ 'ID' ]}
+      fk: { type: foreign_key, attributes: [ 'ID' ], references: 'VALID_WITH_SINGLE_PK' }
+---
+physical:
+  indexes:
+    INVALID_INDEX_NO_SUCH_RELVAR: { relvar: NOSUCH_RELVAR, attributes: ['ID'] }
+    INVALID_INDEX_NO_SUCH_ATTR:   { relvar: VALID_WITH_SINGLE_PK, attributes: ['NOSUCH_ATTR'] }

data/test/unit/core/schema/fixtures/left.yaml

@@ -0,0 +1,46 @@
+--- 
+logical: 
+  ADDED_COLUMNS_ON_LEFT: 
+    heading: 
+      ID:    { domain: Integer, mandatory: true }
+      ADDED: { domain: String,  mandatory: true                       }
+    constraints: 
+      pk: { type: :primary_key, attributes: [ 'ID' ] }
+  ADDED_CONSTRAINT_ON_LEFT: 
+    heading: 
+      ID:    { domain: Integer, mandatory: true }
+    constraints: 
+      pk: { type: :primary_key, attributes: [ 'ID' ] }
+      added_constraint: { type: :foreign_key, attributes: [ 'ID' ], references: ADDED_COLUMNS_ON_LEFT}
+  CONFLICTING_HEADING: 
+    heading: 
+      NO_CONFLICT: { domain: Float, mandatory: true }
+      CONFLICT:    { domain: Integer, mandatory: true }
+    constraints: 
+      pk: { type: :primary_key, attributes: [ 'NO_CONFLICT' ] }
+  DROPPED_COLUMNS_ON_LEFT: 
+    heading: 
+      ID:    { domain: Integer, mandatory: true }
+    constraints: 
+      pk: { type: :primary_key, attributes: [ 'ID' ] }
+  DROPPED_CONSTRAINT_ON_LEFT: 
+    heading: 
+      ID:    { domain: Integer, mandatory: true }
+    constraints: 
+      pk: { type: :primary_key, attributes: [ 'ID' ] }
+  ONLY_ON_LEFT_RELVAR: 
+    heading: 
+      ID:    { domain: Integer, mandatory: true }
+    constraints: 
+      pk: { type: :primary_key, attributes: [ 'ID' ] }
+  SAME:
+    heading: 
+      ID:    { domain: Integer, mandatory: true }
+    constraints: 
+      pk: { type: :primary_key, attributes: [ 'ID' ] }
+---
+physical:
+  indexes:
+    COMMON_INDEX: { relvar: ADDED_COLUMNS_ON_LEFT, attributes: [ 'ID' ] }
+    ONLY_ON_LEFT_INDEX: { relvar: ONLY_ON_LEFT_RELVAR, attributes: [ 'ID' ] }
+  

data/test/unit/core/schema/fixtures/left_minus_right.yaml

@@ -0,0 +1,31 @@
+--- 
+logical: 
+  ADDED_COLUMNS_ON_LEFT: 
+    heading: 
+      ADDED: { domain: String,  mandatory: true }
+    constraints: {}
+  ADDED_CONSTRAINT_ON_LEFT: 
+    heading: {}
+    constraints: 
+      added_constraint: { type: :foreign_key, attributes: [ 'ID' ], references: ADDED_COLUMNS_ON_LEFT}
+  CONFLICTING_HEADING: 
+    heading: 
+      CONFLICT:    { domain: Integer, mandatory: true }
+    constraints: {}
+  DROPPED_COLUMNS_ON_LEFT:
+    heading: {}
+    constraints: {}
+  DROPPED_CONSTRAINT_ON_LEFT:
+    heading: {}
+    constraints: {}
+  ONLY_ON_LEFT_RELVAR: 
+    heading: 
+      ID:    { domain: Integer, mandatory: true }
+    constraints: 
+      pk: { type: :primary_key, attributes: [ 'ID' ] }
+  SAME: {}
+---
+physical:
+  indexes:
+    ONLY_ON_LEFT_INDEX: { relvar: ONLY_ON_LEFT_RELVAR, attributes: [ 'ID' ] }
+  

data/test/unit/core/schema/fixtures/right.yaml

@@ -0,0 +1,46 @@
+--- 
+logical: 
+  ADDED_COLUMNS_ON_LEFT: 
+    heading: 
+      ID:    { domain: Integer, mandatory: true }
+    constraints: 
+      pk: { type: :primary_key, attributes: [ 'ID' ] }
+  ADDED_CONSTRAINT_ON_LEFT: 
+    heading: 
+      ID:    { domain: Integer, mandatory: true }
+    constraints: 
+      pk: { type: :primary_key, attributes: [ 'ID' ] }
+  CONFLICTING_HEADING: 
+    heading: 
+      NO_CONFLICT: { domain: Float,  mandatory: true }
+      CONFLICT:    { domain: String, mandatory: false }
+    constraints: 
+      pk: { type: :primary_key, attributes: [ 'NO_CONFLICT' ] }
+  DROPPED_COLUMNS_ON_LEFT: 
+    heading: 
+      ID:      { domain: Integer, mandatory: true }
+      DROPPED: { domain: String,  mandatory: true                       }
+    constraints: 
+      pk: { type: :primary_key, attributes: [ 'ID' ] }
+  DROPPED_CONSTRAINT_ON_LEFT: 
+    heading: 
+      ID:    { domain: Integer, mandatory: true }
+    constraints: 
+      pk: { type: :primary_key, attributes: [ 'ID' ] }
+      dropped_constraint: { type: :foreign_key, references: ADDED_COLUMNS_ON_LEFT, attributes: [ 'ID' ] }
+  ONLY_ON_RIGHT_RELVAR: 
+    heading: 
+      ID:    { domain: Integer, mandatory: true }
+    constraints: 
+      pk: { type: :primary_key, attributes: [ 'ID' ] }
+  SAME:
+    heading: 
+      ID:    { domain: Integer, mandatory: true }
+    constraints: 
+      pk: { type: :primary_key, attributes: [ 'ID' ] }
+---
+physical:
+  indexes:
+    ONLY_ON_RIGHT_INDEX: { relvar: ONLY_ON_RIGHT_RELVAR, attributes: [ 'ID' ] }
+    COMMON_INDEX: { relvar: ADDED_COLUMNS_ON_LEFT, attributes: [ 'ID' ] }
+  

data/test/unit/core/schema/fixtures/right_minus_left.yaml

@@ -0,0 +1,31 @@
+--- 
+logical: 
+  ADDED_COLUMNS_ON_LEFT:
+    heading: {}
+    constraints: {}
+  ADDED_CONSTRAINT_ON_LEFT:
+    heading: {}
+    constraints: {}
+  CONFLICTING_HEADING: 
+    heading: 
+      CONFLICT:    { domain: String, mandatory: false }
+    constraints: {}
+  DROPPED_COLUMNS_ON_LEFT: 
+    heading:
+      DROPPED: { domain: String,  mandatory: true                       }
+    constraints: {}
+  DROPPED_CONSTRAINT_ON_LEFT: 
+    heading: {}
+    constraints:
+      dropped_constraint: { type: :foreign_key, attributes: [ 'ID' ], references: ADDED_COLUMNS_ON_LEFT }
+  ONLY_ON_RIGHT_RELVAR: 
+    heading: 
+      ID:    { domain: Integer, mandatory: true }
+    constraints: 
+      pk: { type: :primary_key, attributes: [ 'ID' ] }
+  SAME: {}
+---
+physical:
+  indexes:
+    ONLY_ON_RIGHT_INDEX: { relvar: ONLY_ON_RIGHT_RELVAR, attributes: [ 'ID' ] }
+  

data/test/unit/core/schema/fixtures/suppliers_and_parts.yaml

@@ -0,0 +1,30 @@
+--- 
+logical: 
+  SUPPLIERS: 
+    heading: 
+      S#:    { domain: Integer, mandatory: true }
+      NAME:  { domain: String,  mandatory: true }
+      CITY:  { domain: String,  mandatory: true }
+    constraints: 
+      pk: { type: :primary_key, attributes: [ 'S#' ] }
+  PARTS: 
+    heading: 
+      P#:    { domain: Integer, mandatory: true }
+      NAME:  { domain: String,  mandatory: true }
+      COLOR: { domain: String,  mandatory: true }
+    constraints: 
+      pk: { type: :primary_key, attributes: [ 'P#' ] }
+  SUPPLIES: 
+    heading: 
+      S#:    { domain: Integer, mandatory: true }
+      P#:    { domain: Integer, mandatory: true }
+      QTY:   { domain: Integer, mandatory: true }
+    constraints: 
+      pk: { type: :primary_key, attributes: [ 'S#', 'P#' ] }
+      is_a_known_supplier: { type: :foreign_key, attributes: [ 'S#' ], references: :SUPPLIERS }
+      is_a_known_part:     { type: :foreign_key, attributes: [ 'P#' ], references: :PARTS }
+---
+physical:
+  indexes:
+    SUPPLIER_NAMES: { relvar: SUPPLIERS, attributes: [ 'NAME' ] }
+  

data/test/unit/core/schema/fixtures.rb

@@ -0,0 +1,32 @@
+require File.expand_path('../../../fixtures', __FILE__)
+module DbAgile
+  module Fixtures
+    module Core
+      module Schema
+      
+        # Returns a schema file
+        def schema_file(name_or_file)
+          if name_or_file.kind_of?(Symbol)
+            name_or_file = schema_file("#{name_or_file}.yaml") 
+          end
+          unless name_or_file[0, 1] == '/'
+            name_or_file = File.expand_path("../fixtures/#{name_or_file}", __FILE__) 
+          end
+          name_or_file
+        end
+        
+        # Yields block for each schema file
+        def each_schema_file(&block)
+          Dir[File.expand_path("../fixtures/*.yaml", __FILE__)].each(&block)
+        end
+        
+        # Returns a Schema instance for a given name
+        def schema(name_or_file)
+          DbAgile::Core::Schema::yaml_file_load(schema_file(name_or_file))
+        end
+      
+        extend(Schema)
+      end # module Schema
+    end # module Core
+  end # module Fixtures
+end # module DbAgile

data/test/unit/core/schema/merge.spec

@@ -0,0 +1,72 @@
+require File.expand_path('../fixtures', __FILE__)
+describe "DbAgile::Core::Schema#merge" do
+  
+  let(:left)             { DbAgile::Fixtures::Core::Schema::schema(:left)  }
+  let(:right)            { DbAgile::Fixtures::Core::Schema::schema(:right) }
+  let(:empty)            { DbAgile::Fixtures::Core::Schema::schema(:empty) }
+  let(:sap)              { DbAgile::Fixtures::Core::Schema::schema(:suppliers_and_parts) }
+  
+  it "should correctly label all nodes without conflict resolver" do
+    status = DbAgile::Core::Schema
+    schema = DbAgile::Core::Schema::merge(left, right){|l,r| nil}
+    schema.visit{|p, parent|
+      s = case p
+        when DbAgile::Core::Schema::Logical::Relvar
+          case p.name
+            when :ADDED_COLUMNS_ON_LEFT,
+                 :ADDED_CONSTRAINT_ON_LEFT,
+                 :DROPPED_COLUMNS_ON_LEFT,
+                 :DROPPED_CONSTRAINT_ON_LEFT,
+              status::TO_ALTER
+            when :ONLY_ON_LEFT_RELVAR,
+              status::TO_DROP
+            when :ONLY_ON_RIGHT_RELVAR
+              status::TO_CREATE
+            when :SAME
+              status::NO_CHANGE
+          end
+        when DbAgile::Core::Schema::Logical::Attribute
+          case p.name
+            when :ADDED
+              status::TO_DROP
+            when :DROPPED
+              status::TO_CREATE
+          end
+        when DbAgile::Core::Schema::Physical::Index
+          case p.name
+            when :ONLY_ON_LEFT_INDEX
+              status::TO_DROP
+            when :ONLY_ON_RIGHT_INDEX 
+              status::TO_CREATE
+            when :COMMON_INDEX
+              status::NO_CHANGE
+          end
+        when DbAgile::Core::Schema::Logical::Constraint
+          case p.name
+            when :added_constraint
+              status::TO_DROP
+            when :dropped_constraint 
+              status::TO_CREATE
+          end
+      end
+      p.status.should == s unless s.nil?
+    }
+  end
+  
+  it "should raise a conflict error with a resolver" do
+    lambda{ left + right }.should raise_error(DbAgile::SchemaConflictError)
+    lambda{ DbAgile::Core::Schema::merge(left, right) }.should raise_error(DbAgile::SchemaConflictError)
+  end
+  
+  it "should be robust enough when merging not similar things" do
+    lambda{ left + empty }.should_not raise_error
+    lambda{ right + empty }.should_not raise_error
+    lambda{ empty + right }.should_not raise_error
+    lambda{ empty + left }.should_not raise_error
+    lambda{ empty + empty }.should_not raise_error
+    lambda{ sap + empty }.should_not raise_error
+    lambda{ sap + left }.should_not raise_error
+    lambda{ sap + right }.should_not raise_error
+  end
+  
+end

data/test/unit/core/schema/minus.spec

@@ -0,0 +1,26 @@
+require File.expand_path('../fixtures', __FILE__)
+describe "DbAgile::Core::Schema#minus" do
+  
+  let(:left)             { DbAgile::Fixtures::Core::Schema::schema(:left)  }
+  let(:left_minus_right) { DbAgile::Fixtures::Core::Schema::schema(:left_minus_right)  }
+  let(:right)            { DbAgile::Fixtures::Core::Schema::schema(:right)  }
+  let(:right_minus_left) { DbAgile::Fixtures::Core::Schema::schema(:right_minus_left)  }
+  
+  it "should be a valid Schema" do
+    (left - right).should be_kind_of(DbAgile::Core::Schema::DatabaseSchema)
+    (left - left).should be_kind_of(DbAgile::Core::Schema::DatabaseSchema)
+  end
+  
+  it "should be as expected" do
+    (left - right).should_not be_empty
+    (left - right).look_same_as?(left_minus_right).should be_true
+    (right - left).should_not be_empty
+    (right - left).look_same_as?(right_minus_left).should be_true
+  end
+
+  it "should be clean when comparing equal schema" do
+    (left - left).should be_empty
+    (right - right).should be_empty
+  end
+
+end

data/test/unit/core/schema/sanity.spec

@@ -0,0 +1,39 @@
+require File.expand_path('../fixtures', __FILE__)
+describe "DbAgile::Core::Schema's sanity /" do
+  
+  let(:schema){ DbAgile::Fixtures::Core::Schema::schema(:suppliers_and_parts) }
+  
+  it "all objects should looking same as their duplicated" do
+    schema.each{|p,parent| 
+      p.dup.look_same_as?(p).should == true
+    }
+  end
+  
+  it "no object be the same object when duplicated" do
+    schema.each{|p,parent| p.dup.object_id.should_not == p.object_id}
+  end
+  
+  it "no object should be equal as its duplicated" do
+    schema.each{|p,parent| p.dup.should_not == p}
+  end
+  
+  it "should be sane when loaded" do
+    lambda{ schema.send(:_sanity_check, schema) }.should_not raise_error
+  end
+  
+  it "should stay sane after dup" do
+    lambda{ 
+      duplicated = schema.dup
+      duplicated.send(:_sanity_check, duplicated) 
+      schema.send(:_sanity_check, schema)
+    }.should_not raise_error
+  end
+  
+  it "should not share objects when duplicated" do
+    ids = schema.collect{|p, parent| p.object_id}
+    dups = schema.dup.collect{|p, parent| p.object_id}
+    ids.size.should == dups.size
+    (ids & dups).should be_empty
+  end
+  
+end

data/test/unit/core/schema/split.spec

@@ -0,0 +1,58 @@
+require File.expand_path('../fixtures', __FILE__)
+describe "DbAgile::Core::Schema#split" do
+  
+  let(:schema) { DbAgile::Fixtures::Core::Schema::schema(:suppliers_and_parts) }
+
+  it "should split correctly through a logical/physical separation" do
+    splitted = schema.split{|obj| obj.logical? ? :logical : :physical}
+    logical, physical = splitted[:logical], splitted[:physical]
+    logical.visit{|o, parent|
+      unless o.composite?
+        o.logical?.should be_true
+      end
+    }
+    physical.visit{|o, parent|
+      unless o.composite?
+        o.physical?.should be_true
+      end
+    }
+    (logical + physical).look_same_as?(schema).should be_true
+  end
+  
+  it "should split correctly through a logical/physical/constraint separation" do
+    splitted = schema.split{|obj| 
+      if obj.logical? 
+        if obj.constraint?
+          :constraint
+        else
+          :logical 
+        end
+      else
+        :physical
+      end
+    }
+    logical, constraints, physical = splitted[:logical], splitted[:constraint], splitted[:physical]
+    logical.schema_identifier.should == :logical
+    constraints.schema_identifier.should == :constraint
+    physical.schema_identifier.should == :physical
+    logical.visit{|o, parent|
+      unless o.composite?
+        o.logical?.should be_true
+        o.constraint?.should be_false
+      end
+    }
+    constraints.visit{|o, parent|
+      unless o.composite?
+        o.logical?.should be_true
+        o.constraint?.should be_true
+      end
+    }
+    physical.visit{|o, parent|
+      unless o.composite?
+        o.physical?.should be_true
+      end
+    }
+    (logical + physical + constraints).look_same_as?(schema).should be_true
+  end
+  
+end