mysql_framework 0.0.1

data/lib/mysql_framework/sql_query.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module MysqlFramework
+  # This class is used to represent and build a sql query
+  class SqlQuery
+    # This method is called to get any params required to execute this query as a prepared statement.
+    attr_reader :params
+
+    def initialize
+      @sql = ''
+      @params = []
+    end
+
+    # This method is called to access the sql string for this query.
+    def sql
+      @sql.strip
+    end
+
+    # This method is called to start a select query
+    def select(*columns)
+      @sql = "select #{columns.join(',')}"
+      self
+    end
+
+    # This method is called to start a delete query
+    def delete
+      @sql = 'delete'
+      self
+    end
+
+    # This method is called to start an update query
+    def update(table, partition = nil)
+      @sql = "update #{table}"
+      @sql += " partition(p#{partition})" unless partition.nil?
+      self
+    end
+
+    # This method is called to start an insert query
+    def insert(table, partition = nil)
+      @sql += "insert into #{table}"
+      @sql += " partition(p#{partition})" unless partition.nil?
+      self
+    end
+
+    # This method is called to specify the columns to insert into.
+    def into(*columns)
+      @sql += " (#{columns.join(',')})"
+      self
+    end
+
+    # This method is called to specify the values to insert.
+    def values(*values)
+      @sql += " values (#{values.map { |_v| '?' }.join(',')})"
+      values.each do |v|
+        @params << v
+      end
+      self
+    end
+
+    # This method is called to specify the columns to update.
+    def set(values)
+      @sql += ' set '
+      values.each do |k, p|
+        @sql += "`#{k}` = ?, "
+        @params << p
+      end
+      @sql = @sql[0...-2]
+      self
+    end
+
+    # This method is called to specify the table/partition a select/delete query is for.
+    def from(table, partition = nil)
+      @sql += " from #{table}"
+      @sql += " partition(p#{partition})" unless partition.nil?
+      self
+    end
+
+    # This method is called to specify a where clause for a query.
+    def where(*conditions)
+      @sql += ' where' unless @sql.include?('where')
+      @sql += " (#{conditions.join(' and ')}) "
+      conditions.each do |c|
+        @params << c.value
+      end
+      self
+    end
+
+    # This method is called to add an `and` keyword to a query to provide additional where clauses.
+    def and
+      @sql += 'and'
+      self
+    end
+
+    # This method is called to add an `or` keyword to a query to provide alternate where clauses.
+    def or
+      @sql += 'or'
+      self
+    end
+
+    # This method is called to add an `order by` statement to a query
+    def order(*columns)
+      @sql += " order by #{columns.join(',')}"
+      self
+    end
+
+    # This method is called to add an `order by ... desc` statement to a query
+    def order_desc(*columns)
+      order(*columns)
+      @sql += ' desc'
+      self
+    end
+
+    # This method is called to add a limit to a query
+    def limit(count)
+      @sql += " limit #{count}"
+      self
+    end
+
+    # This method is called to add a join statement to a query.
+    def join(table)
+      @sql += " join #{table}"
+      self
+    end
+
+    # This method is called to add the `on` detail to a join statement.
+    def on(column_1, column_2)
+      @sql += " on #{column_1} = #{column_2}"
+      self
+    end
+  end
+end

data/lib/mysql_framework/sql_table.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module MysqlFramework
+  # This class is used to represent a sql table
+  class SqlTable
+    def initialize(name)
+      @name = name
+    end
+
+    # This method is called to get a sql column for this table
+    def [](column)
+      SqlColumn.new(table: @name, column: column)
+    end
+
+    def to_s
+      "`#{@name}`"
+    end
+
+    def to_sym
+      @name.to_sym
+    end
+  end
+end

data/lib/mysql_framework/version.rb

@@ -0,0 +1,3 @@
+module MysqlFramework
+  VERSION = '0.0.1'
+end

data/spec/lib/mysql_framework/connector_spec.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe MysqlFramework::Connector do
+  let(:default_options) do
+    {
+      host:      ENV.fetch('MYSQL_HOST'),
+      port:      ENV.fetch('MYSQL_PORT'),
+      database:  ENV.fetch('MYSQL_DATABASE'),
+      username:  ENV.fetch('MYSQL_USERNAME'),
+      password:  ENV.fetch('MYSQL_PASSWORD'),
+      reconnect: true
+    }
+  end
+  let(:options) do
+    {
+      host:     'host',
+      port:     'port',
+      database: 'database',
+      username: 'username',
+      password: 'password',
+      reconnect: true
+    }
+  end
+  let(:client) { double }
+  let(:gems) { MysqlFramework::SqlTable.new('gems') }
+
+  subject { described_class.new }
+
+  describe '#initialize' do
+    it 'sets default query options on the Mysql2 client' do
+      subject
+      expect(Mysql2::Client.default_query_options[:symbolize_keys]).to eq(true)
+      expect(Mysql2::Client.default_query_options[:cast_booleans]).to eq(true)
+    end
+
+    context 'when options are provided' do
+      subject { described_class.new(options) }
+
+      it 'allows the default options to be overridden' do
+        expect(subject.instance_variable_get(:@options)).to eq(options)
+      end
+    end
+  end
+
+  describe '#check_out' do
+    it 'returns a Mysql2::Client instance from the pool' do
+      expect(Mysql2::Client).to receive(:new).with(default_options).and_return(client)
+      expect(subject.check_out).to eq(client)
+    end
+
+    context 'when the connection pool has a client available' do
+      it 'returns a client instance from the pool' do
+        subject.instance_variable_get(:@connection_pool).push(client)
+        expect(subject.check_out).to eq(client)
+      end
+    end
+  end
+
+  describe '#check_in' do
+    it 'returns the provided client to the connection pool' do
+      expect(subject.instance_variable_get(:@connection_pool)).to receive(:push).with(client)
+      subject.check_in(client)
+    end
+  end
+
+  describe '#with_client' do
+    it 'obtains a client from the pool to use' do
+      allow(subject).to receive(:check_out).and_return(client)
+      expect { |b| subject.with_client(&b) }.to yield_with_args(client)
+    end
+  end
+
+  describe '#execute' do
+    let(:insert_query) do
+      MysqlFramework::SqlQuery.new.insert(gems)
+        .into(
+          gems[:id],
+          gems[:name],
+          gems[:author],
+          gems[:created_at],
+          gems[:updated_at]
+        )
+        .values(
+          SecureRandom.uuid,
+          'mysql_framework',
+          'sage',
+          Time.now,
+          Time.now
+        )
+    end
+
+    it 'executes the query with parameters' do
+      guid = insert_query.params[0]
+      subject.execute(insert_query)
+
+      results = subject.query("SELECT * FROM `gems` WHERE id = '#{guid}';").to_a
+      expect(results.length).to eq(1)
+      expect(results[0][:id]).to eq(guid)
+    end
+  end
+
+  describe '#query' do
+    before :each do
+      allow(subject).to receive(:check_out).and_return(client)
+    end
+
+    it 'retrieves a client and calls query' do
+      expect(client).to receive(:query).with('SELECT 1')
+      subject.query('SELECT 1')
+    end
+  end
+
+  describe '#query_multiple_results' do
+    let(:test) { MysqlFramework::SqlTable.new('test') }
+    let(:manager) { MysqlFramework::Scripts::Manager.new }
+    let(:connector) { MysqlFramework::Connector.new }
+    let(:timestamp) { Time.at(628232400) } # 1989-11-28 00:00:00 -0500
+    let(:guid) { 'a3ccb138-48ae-437a-be52-f673beb12b51' }
+    let(:insert) do
+      MysqlFramework::SqlQuery.new.insert(test)
+        .into(test[:id],test[:name],test[:action],test[:created_at],test[:updated_at])
+        .values(guid,'name','action',timestamp,timestamp)
+    end
+    let(:obj) do
+      {
+        id: guid,
+        name: 'name',
+        action: 'action',
+        created_at: timestamp,
+        updated_at: timestamp,
+      }
+    end
+
+    before :each do
+      manager.initialize_script_history
+      manager.execute
+
+      connector.execute(insert)
+    end
+
+    after :each do
+      manager.drop_all_tables
+    end
+
+    it 'returns the results from the stored procedure' do
+      query = "call test_procedure"
+      result = subject.query_multiple_results(query)
+      expect(result).to be_a(Array)
+      expect(result.length).to eq(2)
+      expect(result[0]).to eq([])
+      expect(result[1]).to eq([obj])
+    end
+  end
+
+  describe '#transaction' do
+    before :each do
+      allow(subject).to receive(:check_out).and_return(client)
+    end
+
+    it 'wraps the client call with BEGIN and COMMIT statements' do
+      expect(client).to receive(:query).with('BEGIN')
+      expect(client).to receive(:query).with('SELECT 1')
+      expect(client).to receive(:query).with('COMMIT')
+
+      subject.transaction do
+        subject.query('SELECT 1')
+      end
+    end
+
+    context 'when an exception occurs' do
+      it 'triggers a ROLLBACK' do
+        expect(client).to receive(:query).with('BEGIN')
+        expect(client).to receive(:query).with('ROLLBACK')
+
+        begin
+          subject.transaction do
+            raise
+          end
+        rescue
+        end
+      end
+    end
+  end
+
+  describe '#default_options' do
+    it 'returns the default options' do
+      expect(subject.default_options).to eq(default_options)
+    end
+  end
+end

data/spec/lib/mysql_framework/logger_spec.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe MysqlFramework do
+  describe 'logger' do
+    it 'returns the logger' do
+      expect(subject.logger).to be_a(Logger)
+    end
+  end
+
+  describe 'set_logger' do
+    let(:logger) { Logger.new(STDOUT) }
+
+    it 'sets the logger' do
+      subject.set_logger(logger)
+      expect(subject.logger).to eq(logger)
+    end
+  end
+end

data/spec/lib/mysql_framework/scripts/base_spec.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe MysqlFramework::Scripts::Base do
+  subject { described_class.new }
+
+  describe '#partitions' do
+    it 'returns the number of paritions' do
+      expect(subject.partitions).to eq(5)
+    end
+  end
+
+  describe '#database_name' do
+    it 'returns the database name' do
+      expect(subject.database_name).to eq('test_database')
+    end
+  end
+
+  describe '#identifier' do
+    it 'throws a NotImplementedError' do
+      expect{ subject.identifier }.to raise_error(NotImplementedError)
+    end
+
+    context 'when @identifier is set' do
+      it 'returns the value' do
+        subject.instance_variable_set(:@identifier, 'foo')
+        expect(subject.identifier).to eq('foo')
+      end
+    end
+  end
+
+  describe '#apply' do
+    it 'throws a NotImplementedError' do
+      expect{ subject.apply }.to raise_error(NotImplementedError)
+    end
+  end
+
+  describe '#rollback' do
+    it 'throws a NotImplementedError' do
+      expect{ subject.rollback }.to raise_error(NotImplementedError)
+    end
+  end
+
+  describe '#generate_partition_sql' do
+    it 'generates the partition sql statement' do
+      expected = "PARTITION p0 VALUES IN (0),\n\tPARTITION p1 VALUES IN (1),\n\tPARTITION p2 VALUES IN (2),\n\tPARTITION p3 VALUES IN (3),\n\tPARTITION p4 VALUES IN (4)"
+      expect(subject.generate_partition_sql).to eq(expected)
+    end
+  end
+
+  describe '.descendants' do
+    it 'returns all descendant classes' do
+      expect(described_class.descendants.length).to eq(3)
+      expect(described_class.descendants).to include(MysqlFramework::Support::Scripts::CreateTestTable,
+                                                     MysqlFramework::Support::Scripts::CreateDemoTable,
+                                                     MysqlFramework::Support::Scripts::CreateTestProc)
+    end
+  end
+
+  describe '#tags' do
+    it 'returns an array' do
+      expect(subject.tags).to eq([])
+    end
+  end
+
+  describe '#update_procedure' do
+    let(:connector) { MysqlFramework::Connector.new }
+    let(:proc_file_path) { 'spec/support/procedure.sql' }
+    let(:drop_sql) do
+      <<~SQL
+        DROP PROCEDURE IF EXISTS test_procedure;
+      SQL
+    end
+
+    before :each do
+      subject.instance_variable_set(:@mysql_connector, connector)
+    end
+
+    it 'drops and then creates the named procedure' do
+      expect(connector).to receive(:query).with(drop_sql).once
+      expect(connector).to receive(:query).with(File.read(proc_file_path)).once
+      subject.update_procedure('test_procedure', proc_file_path)
+    end
+
+    it 'wraps the call in a transaction' do
+      expect(connector).to receive(:transaction)
+      subject.update_procedure('test_procedure', proc_file_path)
+    end
+  end
+end