arc 0.0.1

data/spec/data_stores/abstract/object_definitions_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+require 'arc/data_stores/abstract/object_definitions'
+
+module Arc
+  module DataStores
+    module ObjectDefinitions
+      describe ObjectDefinitions do
+        before :each do
+          @store = AbstractDataStore.new ArcTest.config[:empty]
+        end
+
+        describe Schema do
+          it 'includes Collector' do
+            Schema.included_modules.should include(Collector)
+          end
+          it 'aliases item_names to table_names' do
+            schema = Schema.new nil
+            schema.should respond_to(:table_names)
+          end
+        end
+
+        describe Table do
+          it 'includes Collector' do
+            Table.included_modules.should include(Collector)
+          end
+          it 'aliases item_names to column_names' do
+            table = Table.new nil, :superheros
+            table.should respond_to(:column_names)
+          end
+          describe '#new' do
+            it 'has a name' do
+              Table.new('superheros').name.should == 'superheros'
+            end
+            it 'sets the data store' do                        
+              Table.new('superheros', @store).instance_variable_get(:@data_store).should be(@store)
+            end
+          end
+        end
+
+        describe "Column#new" do
+          it 'sets the datastore' do
+            c = Column.new @store
+            c.instance_variable_get(:@data_store).should be(@store)
+          end
+          it "sets the column's name" do
+            c = Column.new nil, :name => :superheros
+            c.name.should == :superheros
+          end
+          it "sets the column's allows_null" do
+            c = Column.new nil, :allows_null => false
+            c.allows_null?.should == false
+          end
+          it "sets the column's default value" do
+            c = Column.new nil, :default => "superman"
+            c.default.should == "superman"
+          end
+          it "sets the column's primary_key?" do
+            c = Column.new nil, :primary_key => true
+            c.pk?.should be_true
+            c.primary_key?.should be_true
+          end
+          it "sets the string representation of the column's type" do
+            c = Column.new nil, :type => "INTEGER"
+            c.instance_variable_get(:@stype).should == "INTEGER"
+          end
+          it 'throws NotImplementedError when querying type' do
+            c = Column.new nil
+            ->{ c.type }.should raise_error(NotImplementedError)
+          end
+        end
+
+      end
+    end
+  end
+end

data/spec/data_stores/abstract/store_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+module Arc
+  module DataStores
+    describe AbstractDataStore do
+      before :each do
+        @store = AbstractDataStore.new ArcTest.config[:empty]
+        @query = "omg"
+      end
+      
+      it 'proxies methods to the schema' do
+        store = AbstractDataStore.new({})
+        schema = ObjectDefinitions::Schema.new(store)
+        schema.stub(:[]).and_return(ObjectDefinitions::Table.new :fake_table)
+        store.stub!(:schema).and_return(schema)
+        store[:fake_table].should be_a(ObjectDefinitions::Table)
+      end
+      
+      it 'includes arel compatibility' do
+        @store.should be_a(ArelCompatibility)
+      end
+      
+      it 'includes quoting module' do
+        @store.should be_a(Arc::Quoting)
+      end
+      
+      describe '#new' do
+        it 'does not define connection creation' do
+          store = AbstractDataStore.new ArcTest.config[:sqlite]
+          ->{ store.send :with_store }.should raise_error(NotImplementedError)
+        end
+      end
+    
+      describe 'abstract methods throw NotImplementedError' do
+        it '#schema raises not implemented error' do
+          ->{ @store.schema }.should raise_error(NotImplementedError)
+        end
+        it '#create raises not implemented error' do
+          ->{ @store.create @query }.should raise_error(NotImplementedError)
+        end
+        it '#read raises not implemented error' do
+          ->{ @store.read @query }.should raise_error(NotImplementedError)          
+        end
+        it '#update raises not implemented error' do
+          ->{ @store.update @query }.should raise_error(NotImplementedError)          
+        end
+        it '#destroy raises not implemented error' do
+          ->{ @store.destroy @query }.should raise_error(NotImplementedError)          
+        end
+        it '#execute raises not implemented error' do
+          ->{ @store.execute @rquery }.should raise_error(NotImplementedError)          
+        end
+      end
+      
+    end
+  end
+end
+    
+    

data/spec/data_stores/integration/crud_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+module Arc
+  module DataStores
+    describe 'The data store crud operations' do
+            
+      describe '#create' do
+        it 'creates a new record' do
+          ArcTest.with_store do |store|
+            query = "SELECT * FROM superheros WHERE name = 'green hornet'"
+            result = store.read query
+            result.size.should == 0
+          
+            store.create "INSERT INTO superheros (name) VALUES('green hornet');"
+            store.read(query).size.should == 1
+          
+            #cleanup
+            store.destroy "DELETE FROM superheros where name = 'green hornet'"
+          end
+        end
+        
+        it 'returns the record with a populated primary key' do
+          ArcTest.with_store do |store|
+            result = store.create "INSERT INTO superheros (name) VALUES('green lantern')"
+            result[:id].should_not be_nil
+            result[:name].should == 'green lantern'
+            #cleanup
+            store.destroy "DELETE FROM superheros where name = 'green lantern'"
+          end
+        end
+      end
+      
+      describe '#read' do
+        it 'reads existing data' do
+          heros = ['superman', 'batman', 'spiderman']
+          query = "SELECT * FROM superheros"
+          
+          ArcTest.with_store do |store|
+            result = store.read query
+            result.size.should == 3
+            result.each do |h| 
+              h.should be_a(Hash)
+              heros.should include(h[:name])
+            end
+          end
+        end
+      end
+      
+      describe '#update' do
+        it 'updates a record and returns the updated record' do
+          ArcTest.with_store do |store|
+            query = "UPDATE superheros SET name = 'wussy' WHERE name = 'batman'"
+            result = store.update query
+            batman = store.read "SELECT * from superheros WHERE name = 'batman'"
+            batman.size.should == 0
+            batman.should be_a(Enumerable)
+            batman = store.read "SELECT * from superheros WHERE name = 'wussy'"
+            batman.first[:name].should == 'wussy'
+          end
+        end
+      end
+      
+      describe '#destroy' do
+        it 'deletes a record' do 
+          ArcTest.with_store do |store|
+            query = "SELECT * FROM superheros WHERE name = 'batman'"
+            batman = store.read query
+            batman.first[:name].should == 'batman'
+            store.destroy "DELETE FROM superheros WHERE name = 'batman'"
+            batman = store.read query
+            batman.size.should == 0
+            batman.should be_a(Enumerable)
+          end
+        end        
+      end
+
+    end
+  end
+end

data/spec/data_stores/integration/schema_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+module Arc
+  module DataStores
+    module ObjectDefinitions
+      describe "All the Schemas!" do
+        it 'lists the table names' do
+          ArcTest.with_store do |store|
+            store.schema.table_names.should == [:superheros]
+          end
+        end
+      
+        it 'provides a Table object for each table' do
+          ArcTest.with_store do |store|
+            heros = store[:superheros]
+            heros.should be_a(Table)
+            heros.column_names.should include(:id)
+            heros.column_names.should include(:name)
+          end
+        end
+      
+        it 'provides a Column object for each column' do
+          ArcTest.with_store do |store|
+            heros = store[:superheros]
+            id = heros[:id]
+            id.should be_a(Column)
+            id.pk?.should be_true
+            id.allows_null?.should be_false
+            id.default.should be_nil
+            id.name.should == "id"
+            id.type.should == :integer
+          
+            #name column
+            name = heros[:name]
+            name.should be_a(Column)
+            name.pk?.should be_false
+            name.allows_null?.should be_false
+            name.default.should be_nil
+            name.name.should == "name"
+            name.type.should == :varchar
+          end
+        end
+
+      end
+    end
+  end
+end

data/spec/data_stores/mysql/store_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+require 'arc/data_stores/mysql/store'
+
+describe Arc::DataStores::MysqlDataStore do
+  describe "#schema" do
+    it 'is an instance of Arc::DataStores::MysqlSchema' do
+      store = Arc::DataStores::MysqlDataStore.new ArcTest.config[:mysql]
+      store.schema.should be_a(Arc::DataStores::ObjectDefinitions::MysqlSchema)
+    end
+  end
+end

data/spec/data_stores/postgres/store_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+require 'arc/data_stores/postgres/store'
+
+describe Arc::DataStores::PostgresDataStore do
+  describe "#schema" do
+    it 'is an instance of Arc::DataStores::PostgresSchema' do
+      store = Arc::DataStores::PostgresDataStore.new ArcTest.config[:Postgres]
+      store.schema.should be_a(Arc::DataStores::ObjectDefinitions::PostgresSchema)
+    end
+  end
+end

data/spec/data_stores/sqlite/store_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+require 'arc/data_stores/sqlite/store'
+
+describe Arc::DataStores::SqliteDataStore do
+  describe "#schema" do
+    it 'is an instance of Arc::DataStores::SqliteSchema' do
+      store = Arc::DataStores::SqliteDataStore.new(:database => ":memory:")
+      store.schema.should be_a(Arc::DataStores::ObjectDefinitions::SqliteSchema)
+    end
+  end
+end

data/spec/data_stores_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+module Arc
+  describe DataStores do
+    it 'extends Q::Dispatcher' do
+      DataStores.should be_a(Q::Dispatcher)
+    end
+    it "specifies 'DataStore' as the constant_suffix" do
+      DataStores.instance_variable_get(:@constant_suffix).should == "DataStore"
+    end
+    it "specifies 'arc/data_stores/%s_data_store' as the require_pattern" do
+      DataStores.instance_variable_get(:@require_pattern).should == "arc/data_stores/%s/store.rb"
+    end
+  end  
+end

data/spec/quoting_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+module Arc
+  describe Quoting do
+    describe '#quote' do
+      def quoter
+        @quoter ||= Class.new { include Quoting }.new
+      end
+      it 'quotes a column name' do
+        quoter.quote_column('my_column').should == '"my_column"'
+      end
+      it 'quotes a table name' do
+        t = 'my_table'
+        quoter.should_receive(:quote_column_name).with(t)
+        quoter.quote_table(t)
+      end
+      it 'should throw an exception if it cannot find a convertible class' do
+        ->{ quoter.quote(Class.new.new) }.should raise_error(Quoting::CannotCastValueError)
+      end
+      it 'should wrap the symbol using single quotes' do
+        quoter.quote(:superman).should == "'superman'"
+        quoter.quote('superman', Symbol).should == "'superman'"
+      end
+      it 'quotes a string' do
+        quoter.quote("\\").should == "'\\\\'"
+        quoter.quote("'").should == "''''"
+        quoter.quote("my%String", String).should == "'my%String'"
+      end
+      it 'quotes a date object' do
+        date = Date.today
+        fmt = '%Y-%m-%d'
+        quoter.quote(date).should == "'#{date.strftime fmt}'"
+        quoter.quote(date.strftime(fmt), Date).should == "'#{date.strftime fmt}'"
+      end
+      it 'quotes a time object' do
+        time = Time.now
+        fmt = '%Y-%m-%d %H:%M:%S'
+        quoter.quote(time).should == "'#{time.strftime fmt}'"
+        quoter.quote(time.strftime(fmt), Time).should == "'#{time.strftime fmt}'"
+      end
+      it 'quotes a fixnum' do
+        fixnum = 10
+        quoter.quote(fixnum).should == fixnum.to_s
+        quoter.quote(fixnum.to_s, Fixnum).should == fixnum.to_s
+        quoter.quote(fixnum.to_s, nil)
+      end
+      it 'quotes a bignum' do
+        bignum = 1<<100
+        quoter.quote(bignum).should == bignum.to_s
+        quoter.quote(bignum.to_s, Bignum).should == bignum.to_s
+      end
+      it 'quotes a float' do
+        float = 1.2
+        quoter.quote(float).should == float.to_s
+        quoter.quote(float, Float).should == float.to_s
+      end
+      it 'quotes a class name' do
+        klass = String
+        quoter.quote(klass).should == "'String'"
+      end
+      it 'quotes boolean values' do
+        quoter.quote(true, :boolean).should == "'t'"
+        quoter.quote(false, :boolean).should == "'f'"
+      end
+      it 'quotes an object based on column type' do
+        superman = "superman"
+        ArcTest.with_store do |store|
+          c = store[:superheros][:name]
+          quoter.quote(superman, c).should == "'superman'"
+          c = store[:superheros][:id]
+          quoter.quote(10, c).should == '10'
+        end
+      end
+      it 'quotes a bigdecimal' do
+        big_decimal = BigDecimal.new((1 << 100).to_s)
+        quoter.quote(big_decimal).should == big_decimal.to_s('F')
+        quoter.quote(big_decimal.to_s('F'), BigDecimal).should == big_decimal.to_s('F')
+      end
+      it 'quotes nil' do
+        quoter.quote(nil).should == 'NULL'
+        quoter.quote('NULL', NilClass).should == 'NULL'
+        quoter.quote(nil, NilClass).should == 'NULL'
+      end
+      it 'quotes true' do
+        quoter.quote(true).should == "'t'"
+        quoter.quote('true', TrueClass).should == "'t'"
+      end
+      it 'quotes false' do
+        quoter.quote(false).should == "'f'"
+        quoter.quote('false', FalseClass).should == "'f'"
+      end
+      it 'escapes and quotes a binary string' do
+        quoter.quote("\0%", :binary).should == "'%00%25'"
+      end
+    end  
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,81 @@
+#generate a coverage report
+require 'simplecov'
+SimpleCov.start
+
+require 'bundler/setup'
+require 'rspec'
+require 'arc'
+require 'arel'
+require 'q/resource_pool'
+
+
+RSpec.configure do |config|
+  config.after(:all) do
+    ArcTest.drop
+  end
+end
+
+module ArcTest
+  DEFAULT_ADAPTER = 'sqlite'
+  
+  class StoreProvider < ResourcePool
+    def create_resource
+      Arc::DataStores[ArcTest.adapter].new ArcTest.current_config    
+    end
+  end  
+  
+  class << self
+
+    def config_key
+      @config_key ||= (ENV['ARC_ENV'] ||= ArcTest::DEFAULT_ADAPTER).to_sym
+    end    
+    
+    def file_root
+      @file_root  ||= "#{File.dirname __FILE__}/support/schemas"      
+    end    
+    
+    def config
+      @config ||= YAML::load(File.read "#{File.dirname __FILE__}/support/config.yml").symbolize_keys!
+    end
+    
+    def drop
+      return unless @schema_loaded
+      @drop_ddl ||= File.read "#{file_root}/drop_#{config_key}.sql"
+      provider.with_resource { |store| store.schema.execute_ddl @drop_ddl }
+      @schema_loaded = false
+    end
+    
+    def load_schema
+      return if @schema_loaded
+      @ddl ||= File.read "#{file_root}/#{config_key}.sql"
+      provider.with_resource { |store| store.schema.execute_ddl @ddl }
+      @schema_loaded = true
+    end
+    
+    def reset_schema
+      drop
+      load_schema
+    end      
+    
+    def with_store
+      reset_schema
+      provider.with_resource do |store|
+        yield store
+      end
+    end
+    
+    def current_config
+      config[config_key]
+    end
+    
+    def adapter
+      current_config[:adapter].to_sym
+    end
+    
+    private
+    def provider
+      @provider ||= StoreProvider.new nil
+    end
+  end
+
+end