dm-core 0.9.11 → 0.10.0

data/spec/integration/sqlite3_adapter_spec.rb

@@ -1,352 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
-
-if HAS_SQLITE3
-  describe DataMapper::Adapters::Sqlite3Adapter do
-    before :all do
-      @adapter = repository(:sqlite3).adapter
-    end
-
-    describe "auto migrating" do
-      before :all do
-        class ::Sputnik
-          include DataMapper::Resource
-
-          property :id, Serial
-          property :name, DM::Text
-        end
-      end
-
-      it "#upgrade_model should work" do
-        @adapter.destroy_model_storage(repository(:sqlite3), Sputnik)
-        @adapter.storage_exists?("sputniks").should == false
-        Sputnik.auto_migrate!(:sqlite3)
-        @adapter.storage_exists?("sputniks").should == true
-        @adapter.field_exists?("sputniks", "new_prop").should == false
-        Sputnik.property :new_prop, Integer
-        Sputnik.auto_upgrade!(:sqlite3)
-        @adapter.field_exists?("sputniks", "new_prop").should == true
-      end
-    end
-
-    describe "querying metadata" do
-      before :all do
-        class ::Sputnik
-          include DataMapper::Resource
-
-          property :id, Serial
-          property :name, DM::Text
-        end
-      end
-
-      before do
-        Sputnik.auto_migrate!(:sqlite3)
-      end
-
-      it "#storage_exists? should return true for tables that exist" do
-        @adapter.storage_exists?("sputniks").should == true
-      end
-
-      it "#storage_exists? should return false for tables that don't exist" do
-        @adapter.storage_exists?("space turds").should == false
-      end
-
-      it "#field_exists? should return true for columns that exist" do
-        @adapter.field_exists?("sputniks", "name").should == true
-      end
-
-      it "#storage_exists? should return false for tables that don't exist" do
-        @adapter.field_exists?("sputniks", "plur").should == false
-      end
-    end
-
-    describe "database file handling" do
-      it "should preserve the file path for file-based databases" do
-        file = 'newfile.db'
-        DataMapper.setup(:sqlite3file, "sqlite3:#{file}")
-        adapter = repository(:sqlite3file).adapter
-        adapter.uri.path.should == file
-      end
-
-      it "should have a path of just :memory: when using memory databases" do
-        DataMapper.setup(:sqlite3memory, "sqlite3::memory:")
-        adapter = repository(:sqlite3memory).adapter
-        adapter.uri.path.should == ':memory:'
-      end
-    end
-
-    describe "handling transactions" do
-      before :all do
-        class ::Sputnik
-          include DataMapper::Resource
-
-          property :id, Serial
-          property :name, DM::Text
-        end
-      end
-
-      before do
-        Sputnik.auto_migrate!(:sqlite3)
-
-        @transaction = DataMapper::Transaction.new(@adapter)
-      end
-
-      it "should rollback changes when #rollback_transaction is called" do
-        @transaction.commit do |transaction|
-          @adapter.execute("INSERT INTO sputniks (name) VALUES ('my pretty sputnik')")
-          transaction.rollback
-        end
-        @adapter.query("SELECT * FROM sputniks WHERE name = 'my pretty sputnik'").empty?.should == true
-      end
-
-      it "should commit changes when #commit_transaction is called" do
-        @transaction.commit do
-          @adapter.execute("INSERT INTO sputniks (name) VALUES ('my pretty sputnik')")
-        end
-        @adapter.query("SELECT * FROM sputniks WHERE name = 'my pretty sputnik'").size.should == 1
-      end
-    end
-
-    describe "reading & writing a database" do
-      before :all do
-        class ::User
-          include DataMapper::Resource
-
-          property :id, Serial
-          property :name, DM::Text
-        end
-      end
-
-      before do
-        User.auto_migrate!(:sqlite3)
-
-        @adapter.execute("INSERT INTO users (name) VALUES ('Paul')")
-      end
-
-      it 'should be able to #execute an arbitrary query' do
-        result = @adapter.execute("INSERT INTO users (name) VALUES ('Sam')")
-
-        result.affected_rows.should == 1
-      end
-
-      it 'should be able to #query' do
-        result = @adapter.query("SELECT * FROM users")
-
-        result.should be_kind_of(Array)
-        row = result.first
-        row.should be_kind_of(Struct)
-        row.members.map { |m| m.to_s }.should == %w{id name}
-
-        row.id.should == 1
-        row.name.should == 'Paul'
-      end
-
-      it 'should return an empty array if #query found no rows' do
-        @adapter.execute("DELETE FROM users")
-
-        result = nil
-        lambda { result = @adapter.query("SELECT * FROM users") }.should_not raise_error
-
-        result.should be_kind_of(Array)
-        result.size.should == 0
-      end
-    end
-
-    describe "CRUD for serial Key" do
-      before :all do
-        class ::VideoGame
-          include DataMapper::Resource
-
-          property :id, Serial
-          property :name, String
-          property :object, Object
-          property :notes, Text
-        end
-      end
-
-      before do
-        VideoGame.auto_migrate!(:sqlite3)
-      end
-
-      it 'should be able to create a record' do
-        time = Time.now
-        game = repository(:sqlite3) do
-          game = VideoGame.new(:name => 'System Shock', :object => time, :notes => "Test")
-          game.save
-          game.should_not be_a_new_record
-          game.should_not be_dirty
-          game
-        end
-        repository(:sqlite3) do
-          saved = VideoGame.first(:name => 'System Shock')
-          saved.id.should == game.id
-          saved.notes.should == game.notes
-          saved.object.should == time
-        end
-      end
-
-      it 'should be able to read a record' do
-        name = 'Wing Commander: Privateer'
-        id = @adapter.execute('INSERT INTO "video_games" ("name") VALUES (?)', name).insert_id
-
-        game = repository(:sqlite3) do
-          VideoGame.get(id)
-        end
-
-        game.name.should == name
-        game.should_not be_dirty
-        game.should_not be_a_new_record
-      end
-
-      it 'should be able to update a record' do
-        name = 'Resistance: Fall of Mon'
-        id = @adapter.execute('INSERT INTO "video_games" ("name") VALUES (?)', name).insert_id
-
-        game = repository(:sqlite3) do
-          VideoGame.get(id)
-        end
-
-        game.name = game.name.sub(/Mon/, 'Man')
-
-        game.should_not be_a_new_record
-        game.should be_dirty
-
-        repository(:sqlite3) do
-          game.save
-        end
-
-        game.should_not be_dirty
-
-        clone = repository(:sqlite3) do
-          VideoGame.get(id)
-        end
-
-        clone.name.should == game.name
-      end
-
-      it 'should be able to delete a record' do
-        name = 'Zelda'
-        id = @adapter.execute('INSERT INTO "video_games" ("name") VALUES (?)', name).insert_id
-
-        game = repository(:sqlite3) do
-          VideoGame.get(id)
-        end
-
-        game.name.should == name
-
-        repository(:sqlite3) do
-          game.destroy.should be_true
-        end
-        game.should be_a_new_record
-        game.should be_dirty
-      end
-
-      it 'should respond to Resource#get' do
-        name = 'Contra'
-        id = @adapter.execute('INSERT INTO "video_games" ("name") VALUES (?)', name).insert_id
-
-        contra = repository(:sqlite3) { VideoGame.get(id) }
-
-        contra.should_not be_nil
-        contra.should_not be_dirty
-        contra.should_not be_a_new_record
-        contra.id.should == id
-      end
-    end
-
-    describe "CRUD for Composite Key" do
-      before :all do
-        class ::BankCustomer
-          include DataMapper::Resource
-
-          property :bank, String, :key => true
-          property :account_number, String, :key => true
-          property :name, String
-        end
-      end
-
-      before do
-        BankCustomer.auto_migrate!(:sqlite3)
-      end
-
-      it 'should be able to create a record' do
-        customer = BankCustomer.new(:bank => 'Community Bank', :account_number => '123456', :name => 'David Hasselhoff')
-        repository(:sqlite3) do
-          customer.save
-        end
-
-        customer.should_not be_a_new_record
-        customer.should_not be_dirty
-
-        row = @adapter.query('SELECT "bank", "account_number" FROM "bank_customers" WHERE "name" = ?', customer.name).first
-        row.bank.should == customer.bank
-        row.account_number.should == customer.account_number
-      end
-
-      it 'should be able to read a record' do
-        bank, account_number, name = 'Chase', '4321', 'Super Wonderful'
-        @adapter.execute('INSERT INTO "bank_customers" ("bank", "account_number", "name") VALUES (?, ?, ?)', bank, account_number, name)
-
-        repository(:sqlite3) do
-          BankCustomer.get(bank, account_number).name.should == name
-        end
-      end
-
-      it 'should be able to update a record' do
-        bank, account_number, name = 'Wells Fargo', '00101001', 'Spider Pig'
-        @adapter.execute('INSERT INTO "bank_customers" ("bank", "account_number", "name") VALUES (?, ?, ?)', bank, account_number, name)
-
-        customer = repository(:sqlite3) do
-          BankCustomer.get(bank, account_number)
-        end
-
-        customer.name = 'Bat-Pig'
-
-        customer.should_not be_a_new_record
-        customer.should be_dirty
-
-        repository(:sqlite3) do
-          customer.save
-        end
-
-        customer.should_not be_dirty
-
-        clone = repository(:sqlite3) do
-          BankCustomer.get(bank, account_number)
-        end
-
-        clone.name.should == customer.name
-      end
-
-      it 'should be able to delete a record' do
-        bank, account_number, name = 'Megacorp', 'ABC', 'Flash Gordon'
-        @adapter.execute('INSERT INTO "bank_customers" ("bank", "account_number", "name") VALUES (?, ?, ?)', bank, account_number, name)
-
-        customer = repository(:sqlite3) do
-          BankCustomer.get(bank, account_number)
-        end
-
-        customer.name.should == name
-
-        repository(:sqlite3) do
-          customer.destroy.should be_true
-        end
-
-        customer.should be_a_new_record
-        customer.should be_dirty
-      end
-
-      it 'should respond to Resource#get' do
-        bank, account_number, name = 'Conchords', '1100101', 'Robo Boogie'
-        @adapter.execute('INSERT INTO "bank_customers" ("bank", "account_number", "name") VALUES (?, ?, ?)', bank, account_number, name)
-
-        robots = repository(:sqlite3) { BankCustomer.get(bank, account_number) }
-
-        robots.should_not be_nil
-        robots.should_not be_dirty
-        robots.should_not be_a_new_record
-        robots.bank.should == bank
-        robots.account_number.should == account_number
-      end
-    end
-  end
-end

data/spec/integration/sti_spec.rb

@@ -1,273 +0,0 @@
-require 'pathname'
-require Pathname(__FILE__).dirname.expand_path.parent + 'spec_helper'
-
-if HAS_SQLITE3
-  describe DataMapper::AutoMigrations, '.auto_migrate! on STI models with sqlite3' do
-    before :all do
-      @adapter = repository(:sqlite3).adapter
-
-      @property_class = Struct.new(:name, :type, :nullable, :default, :serial)
-
-      class ::Book
-        include DataMapper::Resource
-
-        property :id,       Serial
-        property :title,    String,     :nullable => false
-        property :isbn,     Integer,    :nullable => false
-        property :content,  Text
-        property :class_type, Discriminator
-      end
-
-      class ::Propaganda < Book
-        property :marxist,  Boolean,    :nullable => false, :default => false
-      end
-
-      class ::Fiction < Book
-        property :series,   String
-      end
-
-      class ::ShortStory < Fiction
-        property :moral,    String
-      end
-
-      class ::ScienceFiction < Fiction
-        property :aliens, Boolean
-      end
-
-      class ::SpaceWestern < ScienceFiction
-        property :cowboys, Boolean
-      end
-    end
-
-    describe "with the identity map" do
-      before :all do
-        Book.auto_migrate!(:sqlite3)
-        repository(:sqlite3) do
-          Propaganda.create(:title => "Something", :isbn => "129038")
-        end
-      end
-
-      it "should find the base model in the identity map" do
-        repository(:sqlite3) do
-          book = Book.first
-          book.object_id.should == Propaganda.first.object_id
-        end
-      end
-
-      it "should find the child model in the identity map" do
-        repository(:sqlite3) do
-          book = Propaganda.first
-          book.object_id.should == Book.first.object_id
-        end
-      end
-    end
-
-    describe "with a parent class" do
-      before :all do
-        Book.auto_migrate!(:sqlite3).should be_true
-
-        @table_set = @adapter.query('PRAGMA table_info("books")').inject({}) do |ts,column|
-          default = if 'NULL' == column.dflt_value || column.dflt_value.nil?
-            nil
-          else
-            /^(['"]?)(.*)\1$/.match(column.dflt_value)[2]
-          end
-
-          property = @property_class.new(
-            column.name,
-            column.type.upcase,
-            column.notnull == 0,
-            default,
-            column.pk == 1  # in SQLite3 the serial key is also primary
-          )
-
-          ts.update(property.name => property)
-        end
-
-        @index_list = @adapter.query('PRAGMA index_list("books")')
-      end
-
-      it "should create the child class property columns" do
-        @table_set.keys.should include("series", "marxist")
-      end
-
-      it "should create all property columns of the child classes in the inheritance tree" do
-        @table_set.keys.should include("moral")
-      end
-    end
-
-    describe "with a child class" do
-      before :all do
-        Propaganda.auto_migrate!(:sqlite3).should be_true
-
-        @table_set = @adapter.query('PRAGMA table_info("books")').inject({}) do |ts,column|
-          default = if 'NULL' == column.dflt_value || column.dflt_value.nil?
-            nil
-          else
-            /^(['"]?)(.*)\1$/.match(column.dflt_value)[2]
-          end
-
-          property = @property_class.new(
-            column.name,
-            column.type.upcase,
-            column.notnull == 0,
-            default,
-            column.pk == 1  # in SQLite3 the serial key is also primary
-          )
-
-          ts.update(property.name => property)
-        end
-
-        @index_list = @adapter.query('PRAGMA index_list("books")')
-      end
-
-      it "should create the parent class' property columns" do
-        @table_set.keys.should include("id", "title", "isbn")
-      end
-    end
-
-    describe "with a child class with it's own child class" do
-      before :all do
-        Fiction.auto_migrate!(:sqlite3).should be_true
-
-        @table_set = @adapter.query('PRAGMA table_info("books")').inject({}) do |ts,column|
-          default = if 'NULL' == column.dflt_value || column.dflt_value.nil?
-            nil
-          else
-            /^(['"]?)(.*)\1$/.match(column.dflt_value)[2]
-          end
-
-          property = @property_class.new(
-            column.name,
-            column.type.upcase,
-            column.notnull == 0,
-            default,
-            column.pk == 1  # in SQLite3 the serial key is also primary
-          )
-
-          ts.update(property.name => property)
-        end
-
-        @index_list = @adapter.query('PRAGMA index_list("books")')
-      end
-
-      it "should create the parent class' property columns" do
-        @table_set.keys.should include("id", "title", "isbn")
-      end
-
-      it "should create the child class' property columns" do
-        @table_set.keys.should include("moral")
-      end
-    end
-
-    describe "with a nephew class" do
-      before :all do
-        ShortStory.auto_migrate!(:sqlite3).should be_true
-
-        @table_set = @adapter.query('PRAGMA table_info("books")').inject({}) do |ts,column|
-          default = if 'NULL' == column.dflt_value || column.dflt_value.nil?
-            nil
-          else
-            /^(['"]?)(.*)\1$/.match(column.dflt_value)[2]
-          end
-
-          property = @property_class.new(
-            column.name,
-            column.type.upcase,
-            column.notnull == 0,
-            default,
-            column.pk == 1  # in SQLite3 the serial key is also primary
-          )
-
-          ts.update(property.name => property)
-        end
-        @index_list = @adapter.query('PRAGMA index_list("books")')
-      end
-
-
-      it "should create the grandparent class' property columns" do
-        @table_set.keys.should include("id", "title", "isbn")
-      end
-
-      it "should create the uncle class' property columns" do
-        @table_set.keys.should include("marxist")
-      end
-    end
-
-    describe "with a great-grandchild class" do
-      it "should inherit its parent's properties" do
-        SpaceWestern.properties[:aliens].should_not be_nil
-      end
-      it "should inherit its grandparent's properties" do
-        SpaceWestern.properties[:series].should_not be_nil
-      end
-      it "should inherit its great-granparent's properties" do
-        SpaceWestern.properties[:title].should_not be_nil
-      end
-    end
-
-    describe "with a child class" do
-      before :all do
-        Book.auto_migrate!(:sqlite3)
-        repository(:sqlite3) do
-          ShortStory.create(
-            :title => "The Science of Happiness",
-            :isbn => "129038",
-            :moral => "Bullshit might get you to the top, but it won't keep you there.")
-        end
-      end
-
-      it "should be able to access the properties from the parent collection" do
-        repository(:sqlite3) do
-          Book.all.each do |book|
-            book.title.should_not be_nil
-            book.isbn.should_not be_nil
-            book.moral.should_not be_nil
-          end
-        end
-      end
-    end
-
-    describe "with lazy property" do
-      before :all do
-        Book.auto_migrate!(:sqlite3)
-        repository(:sqlite3) do
-          ShortStory.create(
-            :title => "The Science of Happiness",
-            :isbn => "129038",
-            :content => 'This doesn\'t feel like a normal academic conference. True, the three-day Positive Psychology Summit i',
-            :moral => "Bullshit might get you to the top, but it won't keep you there."
-          )
-
-          ShortStory.create(
-            :title => "Blank as white paper",
-            :isbn => "129039",
-            :content => '',
-            :moral => "none."
-          )
-        end
-      end
-
-      it "should be able to access the properties from the parent collection" do
-        repository(:sqlite3) do
-          books = Book.all
-
-          books.each do |book|
-            book.title.should_not be_nil
-            book.isbn.should_not be_nil
-            book.moral.should_not be_nil
-          end
-
-          books[0].content
-
-          books.each do |book|
-            book.title.should_not be_nil
-            book.isbn.should_not be_nil
-            book.moral.should_not be_nil
-          end
-
-        end
-      end
-    end
-  end
-end