skiima 0.1.000

data/spec/db/skiima/test_table/table.test_table.postgresql.current.sql

@@ -0,0 +1,4 @@
+DROP TABLE IF EXISTS test_table;
+CREATE TABLE test_table (
+  id integer PRIMARY KEY,
+  name varchar(40) NOT NULL CHECK (name <> ''));

data/spec/db/skiima/test_view/view.test_view.mysql.current.sql

@@ -0,0 +1,5 @@
+DROP VIEW IF EXISTS test_view;
+--=============
+CREATE VIEW test_view AS (
+  SELECT * FROM test_table
+);

data/spec/db/skiima/test_view/view.test_view.postgresql.current.sql

@@ -0,0 +1,6 @@
+DROP VIEW IF EXISTS test_view;
+CREATE VIEW test_view AS (
+  SELECT 
+    id AS test_id, 
+    name AS test_name 
+  FROM test_table );

data/spec/helpers/postgresql_spec_helper.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+# def create_test_db
+#   ski = Skiima.new(:postgresql_test)
+#   ski.up(:init_test_db)
+# end
+
+# def drop_test_db
+#   ski = Skiima.new(:postgresql_test)
+#   ski.down(:init_test_db)
+# end

data/spec/mysql2_spec.rb

@@ -0,0 +1,57 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe "Mysql2: " do
+  let(:db_config) { {} }
+  let(:ski) { Skiima.new(:mysql2_test) }
+
+  describe "Connection Setup: " do
+    it "should get the version" do
+      ensure_closed(ski) do |s|
+        s.connection.version.must_be_instance_of Array
+      end
+    end
+
+    it "can set a different encoding" do
+      db_config.merge!(:encoding => 'utf-8')
+      skip
+    end
+
+    it "can set a different timezone" do
+      skip
+    end
+  end
+
+  describe "Create/Drop Database: " do
+    
+  end  
+
+  describe "Create/Drop Tables: " do
+    it 'should be able to create and drop tables' do
+      ensure_closed(ski) do |s|
+        s.connection.table_exists?('test_table').must_equal false
+        s.up(:test_table)
+        s.connection.table_exists?('test_table').must_equal true
+        s.down(:test_table)
+        s.connection.table_exists?('test_table').must_equal false
+      end
+    end
+  end
+
+  describe "Create/Drop View: " do
+    it 'should be able to create and drop views' do
+      ensure_closed(ski) do |s|
+        s.connection.table_exists?('test_table').must_equal false
+        s.connection.view_exists?('test_view').must_equal false
+
+        s.up(:test_table, :test_view)
+        s.connection.table_exists?('test_table').must_equal true
+        s.connection.view_exists?('test_view').must_equal true
+
+        s.down(:test_table, :test_view)
+        s.connection.table_exists?('test_table').must_equal false
+        s.connection.view_exists?('test_view').must_equal false
+      end
+    end
+  end
+end

data/spec/mysql_spec.rb

@@ -0,0 +1,100 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe "Mysql: " do
+  let(:db_config) { {} }
+  let(:ski) { Skiima.new(:mysql_test) }
+
+  describe "Connection Setup: " do
+    it "should get the version" do
+      ensure_closed(ski) do |s|
+        s.connection.version.must_be_instance_of Array
+      end
+    end
+
+    it "can set a different encoding" do
+      db_config.merge!(:encoding => 'utf-8')
+      skip
+    end
+  end
+
+  describe "Create/Drop Database: " do
+
+  end  
+
+  describe "Create/Drop Tables: " do
+    it 'should create and drop tables' do
+      ensure_closed(ski) do |s|
+        s.connection.table_exists?('test_table').must_equal false
+        s.up(:test_table)
+        s.connection.table_exists?('test_table').must_equal true
+        s.down(:test_table)
+        s.connection.table_exists?('test_table').must_equal false
+      end
+    end
+  end
+
+  describe "Create/Drop View: " do
+    it 'should create and drop views' do
+      ensure_closed(ski) do |s|
+        s.connection.table_exists?('test_table').must_equal false
+        s.connection.view_exists?('test_view').must_equal false
+
+        s.up(:test_table, :test_view)
+        s.connection.table_exists?('test_table').must_equal true
+        s.connection.view_exists?('test_view').must_equal true
+
+        s.down(:test_table, :test_view)
+        s.connection.table_exists?('test_table').must_equal false
+        s.connection.view_exists?('test_view').must_equal false
+      end
+    end
+  end
+
+  describe "Create/Drop Index: " do
+    it 'should create and drop indexes' do
+      ensure_closed(ski) do |s|
+        s.connection.table_exists?('test_table').must_equal false
+        s.connection.index_exists?('test_index', :attr => ['test_table']).must_equal false
+
+        s.up(:test_table, :test_index)
+        s.connection.table_exists?('test_table').must_equal true
+        s.connection.index_exists?('test_index', :attr => ['test_table']).must_equal true
+
+        s.down(:test_table, :test_index)
+        s.connection.table_exists?('test_table').must_equal false
+        s.connection.index_exists?('test_index', :attr => ['test_table']).must_equal false
+      end
+    end
+  end
+
+  describe "Column Names: " do
+    it "should get a list of column names from a table" do
+      ensure_closed(ski) do |s|
+        s.connection.table_exists?('test_column_names').must_equal false
+        s.up(:test_column_names)
+
+        s.connection.column_names('test_column_names').must_include 'id', 'first_name'
+        s.down(:test_column_names)
+        # { s.connection.column_names('test_column_names') }.must_raise Error
+      end
+    end
+  end
+
+  describe "Create/Drop Procs: " do
+    it "should create and drop procs, with or without a drop script" do
+      ensure_closed(ski) do |s|
+        s.connection.proc_exists?('test_proc').must_equal false
+        s.connection.proc_exists?('test_proc_drop').must_equal false
+
+        s.up(:test_proc)
+        s.connection.proc_exists?('test_proc').must_equal true
+        s.connection.proc_exists?('test_proc_drop').must_equal true
+
+        s.down(:test_proc)
+        s.connection.proc_exists?('test_proc').must_equal false
+        s.connection.proc_exists?('test_proc_drop').must_equal false
+      end
+    end
+  end
+end

data/spec/postgresql_spec.rb

@@ -0,0 +1,138 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'helpers/postgresql_spec_helper'
+
+describe "Postgresql: " do
+  let(:ski) { Skiima.new(:postgresql_test) }
+  
+  describe "Connection Setup: " do
+    it "should get the version" do
+      ensure_closed(ski) do |s|
+        s.connection.version.must_be_instance_of Fixnum
+      end
+    end
+
+    it "should get the timezone" do
+      ensure_closed(ski) do |s|
+        s.connection.local_tz.must_be_instance_of String
+      end
+    end
+  end
+
+  describe "Create/Drop Databases: " do
+    it "should create and drop databases" do
+      skip # permissions
+    end
+  end
+
+  describe "Create/Drop Table: " do
+    it "should create and drop a table" do
+      ensure_closed(ski) do |skiima|
+        within_transaction(skiima) do |s|
+          s.connection.table_exists?('test_table').must_equal false
+          s.up(:test_table)
+          s.connection.table_exists?('test_table').must_equal true
+          s.down(:test_table)
+          s.connection.table_exists?('test_table').must_equal false
+        end
+      end
+    end
+
+    it "should handle multiple schemas in a database" do
+      skip # pending
+    end
+  end
+
+  describe "Create/Drop Schema: " do
+    #schema's cant be rolled back
+    it "should create and drop schemas" do
+      ensure_closed(ski) do |s|
+        s.connection.schema_exists?('test_schema').must_equal false
+        s.up(:test_schema)
+        s.connection.schema_exists?('test_schema').must_equal true
+        s.down(:test_schema)
+        s.connection.schema_exists?('test_schema').must_equal false
+      end
+    end
+  end
+
+  describe "Create/Drop View: " do
+    it "should create and drop views" do
+      ensure_closed(ski) do |skiima|
+        within_transaction(skiima) do |s|
+          s.connection.table_exists?('test_table').must_equal false
+          s.connection.view_exists?('test_view').must_equal false
+
+          s.up(:test_table, :test_view)
+          s.connection.table_exists?('test_table').must_equal true
+          s.connection.view_exists?('test_view').must_equal true
+
+          s.down(:test_table, :test_view)
+          s.connection.table_exists?('test_table').must_equal false
+          s.connection.view_exists?('test_view').must_equal false
+        end
+      end
+    end
+  end
+
+  describe "Create/Drop Rules: " do
+    it "should create and drop rules" do
+      ensure_closed(ski) do |skiima|
+        within_transaction(skiima) do |s|
+          s.connection.table_exists?('test_table').must_equal false
+          s.connection.view_exists?('test_view').must_equal false
+          s.connection.rule_exists?('test_rule', :attr => ['test_view']).must_equal false
+
+          s.up(:test_table, :test_view, :test_rule)
+          s.connection.table_exists?('test_table').must_equal true
+          s.connection.view_exists?('test_view').must_equal true
+          s.connection.rule_exists?('test_rule', :attr => ['test_view']).must_equal true
+
+          s.down(:test_table, :test_view, :test_rule)
+          s.connection.table_exists?('test_table').must_equal false
+          s.connection.view_exists?('test_view').must_equal false
+          s.connection.rule_exists?('test_rule', :attr => ['test_view']).must_equal false
+        end
+      end
+    end
+  end
+
+  describe "Create/Drop Indexes: " do
+    it "should create and drop indexes" do
+      ensure_closed(ski) do |skiima|
+        within_transaction(skiima) do |s|
+          s.connection.table_exists?('test_table').must_equal false
+          s.connection.index_exists?('test_index', :attr => ['test_table']).must_equal false
+
+          s.up(:test_table, :test_index)
+          s.connection.table_exists?('test_table').must_equal true
+          s.connection.index_exists?('test_index', :attr => ['test_table']).must_equal true
+
+          s.down(:test_table, :test_index)
+          s.connection.table_exists?('test_table').must_equal false
+          s.connection.index_exists?('test_index', :attr => ['test_table']).must_equal false
+        end
+      end
+    end
+  end
+
+  describe "Create/Drop Users: " do
+    
+  end
+
+  describe "Column Names: " do
+    it "should get a list of column names from a table" do
+      ensure_closed(ski) do |skiima|
+        within_transaction(skiima) do |s|
+          s.connection.table_exists?('test_column_names').must_equal false
+          s.up(:test_column_names)
+
+          s.connection.column_names('test_column_names').must_include 'id', 'first_name'
+          s.down(:test_column_names)
+          # { s.connection.column_names('test_column_names') }.must_raise Error
+        end
+      end  
+    end
+  end
+end
+

data/spec/skiima/db_adapters/mysql_adapter_spec.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'skiima/db_adapters/mysql_adapter'
+
+describe "Skiima::DbAdapters::MysqlAdapter" do
+  let(:db) { Skiima.read_db_yaml(Skiima.full_database_path)[:mysql_test] }
+  let(:mysql_params) { [db[:host], db[:username], db[:password], db[:database], db[:port], db[:socket], Mysql::CLIENT_MULTI_RESULTS] }
+  let(:mysql_adapter) { Skiima::DbAdapters::MysqlAdapter.new(Mysql.init, nil, mysql_params, db) }
+
+  describe "#initialize" do
+    before(:each) do
+      Mysql.any_instance.expects(:real_connect)
+      Skiima::DbAdapters::MysqlAdapter.any_instance.expects(:version)
+      Skiima::DbAdapters::MysqlAdapter.any_instance.expects(:configure_connection)
+    end 
+
+    it 'should set connection options and config' do
+      mysql_adapter.instance_variable_get(:@connection_options).must_equal mysql_params
+      mysql_adapter.instance_variable_get(:@config).must_equal db
+    end
+
+    it 'should set ssl options if included' do
+      db.merge!({:sslkey => '123'})
+      Mysql.any_instance.expects(:ssl_set)
+
+      mysql_adapter
+    end
+
+    it 'should set encoding options if included' do
+      utf = 'utf-8'
+      db.merge!({:encoding => utf})
+      Mysql.any_instance.expects(:options).with(Mysql::SET_CHARSET_NAME, utf)
+
+      mysql_adapter
+    end
+  end
+  
+end

data/spec/skiima/db_adapters/postgresql_adapter_spec.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'skiima/db_adapters/postgresql_adapter'
+
+describe "Skiima::DbAdapters::PostgresqlAdapter" do
+  let(:db) { Skiima.read_db_yaml(Skiima.full_database_path)[:test] }
+  let(:pg_params) { [db[:host], db[:port], nil, nil, db[:database], db[:username], db[:password]] }
+  let(:pg_adapter) { Skiima::DbAdapters::PostgresqlAdapter.new(nil, nil, pg_params, db) }
+
+  describe "#initialize" do
+    it 'should set params, attempt to connect, check the version, and get the timezone' do
+      Skiima::DbAdapters::PostgresqlAdapter.any_instance.expects(:connect)
+      Skiima::DbAdapters::PostgresqlAdapter.any_instance.expects(:postgresql_version).returns(80300)
+      Skiima::DbAdapters::PostgresqlAdapter.any_instance.expects(:get_timezone).returns('UTC')
+
+      pg_adapter.version.must_equal 80300
+      pg_adapter.local_tz.must_equal 'UTC'
+    end
+  end
+end

data/spec/skiima/db_adapters_spec.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Skiima::DbAdapters::Resolver do
+  let(:db) { Skiima.read_db_yaml(Skiima.full_database_path)[:test] }
+
+  it "should force an adapter to be specified" do
+    proc{ Skiima::DbAdapters::Resolver.new({}) }.must_raise(Skiima::AdapterNotSpecified)
+  end
+
+  it "should raise an error when there is not a valid adapter defined" do
+    db[:adapter] = 'undefsql'
+    proc{ Skiima::DbAdapters::Resolver.new(db) }.must_raise(LoadError)
+  end
+
+  it "should load the adapter class" do
+    # bad test for ordering
+    # proc { Skiima::DbAdapters::PostgresqlAdapter }.must_raise(NameError)
+
+    Skiima::DbAdapters::Resolver.new(db)
+    Skiima::DbAdapters::PostgresqlAdapter.must_be_instance_of Class
+  end
+
+  it "should set the adapter method" do
+    Skiima::DbAdapters::Resolver.new(db).adapter_method.must_equal "postgresql_connection"
+  end
+end
+
+describe Skiima::DbAdapters::Base do
+  
+end

data/spec/skiima/dependency_spec.rb

@@ -0,0 +1,94 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Skiima::Dependency::Script do
+  let(:group) { 'test_view' }
+  let(:adapter) { 'postgresql' }
+  let(:version) { 'current' }
+  let(:scriptname) { 'view.test_view' }
+  subject { Skiima::Dependency::Script.new(group, adapter, version, scriptname) }
+
+  describe '#initialize' do
+    it 'should split the object type and name from the scriptname' do
+      subject.type.must_equal 'view'
+      subject.name.must_equal 'test_view'
+    end
+  end
+
+  describe "#target" do
+    it 'should return the target object for rules, triggers, etc' do
+      rule_script = Skiima::Dependency::Script.new(group, adapter, version, 'rule.test_rule.test_view')
+      rule_script.attr[0].must_equal 'test_view'
+    end
+  end
+
+  describe "#filename" do
+    it 'should return the filename' do
+      subject.filename.must_equal "#{subject.type}.#{subject.name}.#{adapter}.#{version}.sql"
+    end
+  end
+
+  describe "#down_filename" do
+    it 'returns the filename to look for'
+  end
+
+  describe "down_script?" do
+    it 'should return true when the file exists'
+    it 'should return false when a script cant be found'
+  end
+
+  describe '#read_content' do
+    it 'should store file content' do
+      subject.read_content(:up, Skiima.full_scripts_path).must_include "test_view"
+    end
+  end
+
+  describe '#interpolate_sql' do
+    it 'should replace vars with their substituions' do
+      interpolation_vars = {:database => 'db_name', :schema => 'schema_name', :table => 'table_name'}
+      subject.content = 'SELECT * FROM &database.&schema.&table'
+      subject.interpolate_sql('&', interpolation_vars)
+      subject.sql.must_equal "SELECT * FROM db_name.schema_name.table_name"
+    end
+  end
+end
+
+describe Skiima::Dependency::Reader do
+  let(:groups) { [:init_test_db, :test_table] }
+  let(:depends) { Skiima.read_depends_yaml(Skiima.full_depends_path) }
+  let(:adapter) { :postgresql }
+  subject { Skiima::Dependency::Reader.new(depends, adapter) }
+
+  describe "#initialize" do
+    it 'should default the version to current' do
+      subject.version.must_equal :current
+    end
+  end
+
+  describe "#adapter" do
+    it 'should return mysql if using a mysql/mysql2 adapter' do
+      subject.adapter = 'mysql'
+      subject.adapter.must_equal :mysql
+      subject.adapter = 'mysql2'
+      subject.adapter.must_equal :mysql
+    end
+  end
+
+  describe "#get_load_order" do
+    it 'should create a list of scripts under the groups, adapter and version specified' do
+      scripts = subject.get_load_order(*groups)
+      scripts.first.name.must_equal('skiima_test')
+      scripts.last.name.must_equal('test_table')
+    end
+    
+    it 'should return a blank list when the groups, adapter or version have no entries' do
+      reader = Skiima::Dependency::Reader.new(depends, adapter)
+      scripts = reader.get_load_order(:blank_group)
+      scripts.count.must_equal 0
+
+      reader = Skiima::Dependency::Reader.new(depends, :postgresql)
+      scripts = reader.get_load_order(:only_pg)
+      scripts.first.name.must_equal('only_pg')
+    end
+  end
+end

data/spec/skiima_spec.rb

@@ -0,0 +1,97 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Skiima do
+  describe "Module Configuration Options" do
+    it "should set the proper module defaults" do
+      Skiima.root_path.must_equal SKIIMA_ROOT
+      Skiima.config_path.must_equal 'config'
+      Skiima.database_yaml.must_equal 'database.yml'
+      Skiima.scripts_path.must_equal 'db/skiima'
+      Skiima.depends_yaml.must_equal 'depends.yml'
+    end
+  end
+
+  describe "#message" do
+    it "should default to using the locale specified in config block" do
+      Skiima.msg('messages', 'create', 'start').must_equal "Creating objects for @class"
+    end
+  end
+
+  # describe "implementation" do
+  #   let(:groups) { %w(friend team_member) }
+  #                                                                   {}
+  #   it "should take a list of strings and run their SQL up scripts for them" do
+  #     Skiima.expects(:new).with({}).returns(base = Skiima::Base.new)
+  #     base.expects(:up).with(*groups)
+  #     Skiima.up('friend', 'team_member')
+  #   end
+
+  #   it "should take a list of strings and run their SQL down scripts for them" do
+  #     Skiima.expects(:new).with({}).returns(base = Skiima::Base.new)
+  #     base.expects(:down).with(*groups)
+  #     Skiima.down('friend', 'team_member')
+  #   end
+
+  #   describe "Errors: " do
+  #     it "should return a group not found error when a class/string can't be found in depends.yml" do
+
+  #     end
+  #   end
+  # end
+end
+
+describe Skiima::Loader do
+  subject { Skiima::Loader.new(:test) }
+
+  describe "#config" do
+    before(:each) { Skiima::Loader.any_instance.expects(:make_connection).returns(true) }
+  	let(:config_path) { 'config' }
+  	let(:db_yaml) { 'database.yml' }
+
+  	it "inherits module defaults" do
+      subject.root_path.must_equal SKIIMA_ROOT
+      subject.config_path.must_equal config_path
+      subject.database_yaml.must_equal db_yaml
+    end
+
+    it "overrides module defaults with options hash" do
+      ski_too = Skiima::Loader.new(:test, :logging_out => 'STDERR')
+      ski_too.logging_out.must_equal 'STDERR'
+    end
+  end
+
+  describe "Logger: " do
+    before(:each) { Skiima::Loader.any_instance.expects(:make_connection).returns(true) }
+
+    it "creates a logger with the correct options" do
+      subject.logger.class.must_equal ::Logger
+    end
+  end
+
+  # describe "Implementation: " do
+  #   let(:groups) { groups = %w(friend team_member) }
+  #   let(:scripts) do 
+  #     scripts = %w(view_friends rule_view_friends_delete rule_view_friends_insert).map {|s| Skiima::Dependency::Script.new('friend', s)} 
+  #   end
+
+  #   it "should take a list of strings and run their SQL up scripts for them" do
+  #     subject.expects(:execute_dependency_reader).with(groups).returns(scripts)
+  #     subject.expects(:execute_loader).with(:up, scripts).returns('Great Success!!')
+  #     subject.up(*groups)
+  #   end
+
+  #   it "should take a list of strings and run their SQL down scripts for them" do
+  #     subject.expects(:execute_dependency_reader).with(groups).returns(scripts)
+  #     subject.expects(:execute_loader).with(:down, scripts).returns('Great Success!!')
+  #     subject.down('friend', 'team_member')
+  #   end
+
+  #   describe "Errors: " do
+  #     it "should return a group not found error when a class/string can't be found in depends.yml" do
+  #       proc { subject.up('friendz', 'team_memberz') }.must_raise(Skiima::SqlGroupNotFound)
+  #     end
+  #   end
+  # end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/spec')
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+gem "minitest"
+require "minitest/spec"
+require "minitest/autorun"
+require "minitest/matchers"
+require "minitest/pride"
+require "mocha"
+require "pry"
+
+require "skiima"
+
+SKIIMA_ROOT = File.dirname(__FILE__)
+
+Skiima.setup do |config|
+  config.root_path = SKIIMA_ROOT
+  config.config_path = 'config'
+  config.scripts_path = 'db/skiima'
+  config.locale = :en
+end
+
+def ensure_closed(s, &block)
+  yield s
+ensure
+  s.connection.close
+end
+
+def within_transaction(s, &block)
+  s.connection.begin_db_transaction
+  yield s
+ensure
+  s.connection.rollback_db_transaction
+end