mysql_expectations 1.0.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NGI4NWUzN2QwNTI4M2VlNjllMjY0ZTJjNTM3OWJlNmU4OWJmZTIwZg==
+  data.tar.gz: !binary |-
+    OTc2Y2Y2OWY5ZTQzOTg1ZDIxOTk0MDcyNmRiZDZlZGM0NDkxYWQ4Yg==
+SHA512:
+  metadata.gz: !binary |-
+    ZTJhYjNiYmVhOGYzZmVmM2Y3YWE4OTIyYWNhN2MxNjQ1MjI0YWU1NDllMDMx
+    MjU1YjM4NmZkNzA1MGJmOGFkNDIzMWE1NTUyZWIxZDk0ZTdjODAxZGU3NGI0
+    ZDU5NjRiNTY1MjM5MDIyZDgwM2I4ZmEzYWVhMTVjMmY4OWQyOTc=
+  data.tar.gz: !binary |-
+    MjcwMTUxYzVjYmE0ODViZmFjMDhmYmU4YWE2ZTQ1ZGIyNjE3N2YxZDNlYmQ1
+    MmIzZGY0NjE0YzZmMzBiOTRiMTliYTgyNThkZGQ2YmY0OWI2ODkzN2NkMDlj
+    N2MyYTk4Zjg4NzU5MmJhMTNhMjE5Mzg1NWMxYWNiMDZjNzEzNzI=

data/lib/mysql_expectations/array_refinements.rb

@@ -0,0 +1,46 @@
+# Copyright (c) 2015 Yahoo Inc.
+# Copyrights licensed under the New BSD License.
+# See the accompanying LICENSE file for terms.
+
+module MySQLExpectations
+  # Monkey patch Array to have #to_sentence.
+  # #to_sentence converts the array to a delimited string.
+  # you pick the delimiter, you pick the coordinating
+  # conjunction, you pick serial delimiter or not.
+  #
+  # Serial delimiter (or serial comma in the case the
+  # delimiter is a comma), means to include the comma
+  # between the last two items in the list.
+  #
+  module ArrayRefinements
+    refine Array do
+      def quote_elements(quote_with)
+        map { |e| "#{quote_with}#{e}#{quote_with}" }
+      end
+
+      def delimited_conjunction(conjunction, delimiter, serial_delimiter)
+        delimited_conjunction = conjunction
+        delimited_conjunction += ' ' unless conjunction.empty?
+        if serial_delimiter
+          delimited_conjunction = delimiter + delimited_conjunction
+        else
+          delimited_conjunction = ' ' + delimited_conjunction
+        end
+        delimited_conjunction
+      end
+
+      def to_sentence(
+        quote_with: "'", delimiter:  ', ', conjunction: 'and',
+        serial_delimiter: true
+      )
+        return '' if self.empty?
+        words = quote_elements(quote_with)
+        return words[0] if words.size == 1
+        return "#{words[0]} #{conjunction} #{words[1]}" if words.size == 2
+        delimited_conjunction = delimited_conjunction(
+          conjunction, delimiter, serial_delimiter)
+        [words[0...-1].join(delimiter), words.last].join(delimited_conjunction)
+      end
+    end
+  end
+end

data/lib/mysql_expectations/database.rb

@@ -0,0 +1,55 @@
+# Copyright (c) 2015 Yahoo Inc.
+# Copyrights licensed under the New BSD License.
+# See the accompanying LICENSE file for terms.
+
+require 'mysql_expectations/table'
+
+module MySQLExpectations
+  # Allows assertions on a database
+  #
+  class Database
+    attr_reader
+
+    def initialize(database_element)
+      @database_element = database_element
+    end
+
+    def name
+      @database_element.attributes['name']
+    end
+
+    def table?(name)
+      query = "table_structure[@name='#{name}']"
+      !@database_element.elements[query].nil?
+    end
+
+    alias_method :has_table?, :table?
+
+    def table(name)
+      query = "table_structure[@name='#{name}']"
+      table_element = @database_element.elements[query]
+      Table.new table_element if table_element
+    end
+
+    def tables
+      query = 'table_structure'
+      tables = []
+      @database_element.elements.each(query) do |table_element|
+        tables << Table.new(table_element)
+      end
+      tables
+    end
+
+    def method_missing(method, *arguments, &block)
+      if arguments.empty? && block.nil?
+        table_name = method.to_s
+        return table(table_name) if table?(table_name)
+      end
+      super
+    end
+
+    def respond_to_missing?(method, *)
+      table?(method.to_s) || super
+    end
+  end
+end

data/lib/mysql_expectations/field.rb

@@ -0,0 +1,41 @@
+# Copyright (c) 2015 Yahoo Inc.
+# Copyrights licensed under the New BSD License.
+# See the accompanying LICENSE file for terms.
+
+module MySQLExpectations
+  # Allows assertions on a database
+  #
+  class Field
+    def initialize(field_element)
+      @field_element = field_element
+    end
+
+    def name
+      @field_element.attributes['Field']
+    end
+
+    def definition?(expected_options)
+      expected_options.each do |expected_key, expected_value|
+        value = @field_element.attributes[expected_key]
+        return false if value.nil? || value != expected_value
+      end
+      true
+    end
+
+    alias_method :has_definition?, :definition?
+
+    def type
+      @field_element.attributes['Type']
+    end
+
+    def type?(expected_type)
+      expected_type == type
+    end
+
+    alias_method :has_type?, :type?
+
+    def nullable?
+      @field_element.attributes['Null'] == 'YES'
+    end
+  end
+end

data/lib/mysql_expectations/key.rb

@@ -0,0 +1,106 @@
+# Copyright (c) 2015 Yahoo Inc.
+# Copyrights licensed under the New BSD License.
+# See the accompanying LICENSE file for terms.
+
+require 'mysql_expectations/key_field'
+
+module MySQLExpectations
+  # An table key has a name and a sequence of index fields.
+  #
+  class Key
+    attr_reader :name, :unique, :fields
+
+    UNIQUE = true
+    NON_UNIQUE = false
+
+    def initialize(name, unique = nil, fields)
+      @name = name
+      @unique = unique
+      @fields = []
+      fields.each do |field|
+        field = KeyField.new(field) unless field.instance_of?(KeyField)
+        @fields << field
+      end
+    end
+
+    def ==(other)
+      name == other.name && unique == other.unique && fields == other.fields
+    end
+
+    def to_s
+      result = "{ '#{name}', #{uniqueness_to_s}, ["
+      fields.each_with_index do |field, index|
+        result << ', ' if index > 0
+        result << field.to_s
+      end
+      result << '] }'
+      result
+    end
+
+    def uniqueness_to_s
+      return 'nil' if unique.nil?
+      return 'UNIQUE' if unique == true
+      return 'NON_UNIQUE' if unique == false
+    end
+
+    def self.key?(table_element, key_name)
+      result = table_element.elements["key[@Key_name='#{key_name}']"]
+      !result.nil?
+    end
+
+    def self.load_key(table_element, key_name)
+      if key?(table_element, key_name)
+        key_fields = load_key_fields(table_element, key_name)
+        unique = load_uniqueness(table_element, key_name)
+        return Key.new(key_name, unique, key_fields)
+      end
+      nil
+    end
+
+    def self.load_all_keys(table_element)
+      keys = {}
+      table_element.elements.each('key') do |e|
+        key_name = e.attributes['Key_name']
+        unless keys.key? key_name
+          keys[key_name] = load_key(table_element, key_name)
+        end
+      end
+      keys.values
+    end
+
+    def self.find_key_element(table_element, index_name, field_index)
+      query = "key[@Key_name='#{index_name}' and " \
+        "@Seq_in_index='#{field_index + 1}']"
+      table_element.elements[query]
+    end
+
+    def self.collation_from_s(collation)
+      return KeyField::ORDER_DESC if collation == 'D'
+      KeyField::ORDER_ASC
+    end
+
+    def self.load_key_field(key_element)
+      name = key_element.attributes['Column_name']
+      collation = key_element.attributes['Collation']
+      collation = collation_from_s(collation)
+      length = key_element.attributes['Length']
+      KeyField.new(name, collation, length)
+    end
+
+    def self.load_uniqueness(table_element, key_name)
+      key_element = find_key_element(table_element, key_name, 0)
+      return nil if key_element.nil?
+      (key_element.attributes['Non_unique'] == '0')
+    end
+
+    def self.load_key_fields(table_element, key_name)
+      key_fields = []
+      (0..1000).each do |field_index|
+        key_element = find_key_element(table_element, key_name, field_index)
+        break if key_element.nil?
+        key_fields << load_key_field(key_element)
+      end
+      key_fields
+    end
+  end
+end

data/lib/mysql_expectations/key_field.rb

@@ -0,0 +1,59 @@
+# Copyright (c) 2015 Yahoo Inc.
+# Copyrights licensed under the New BSD License.
+# See the accompanying LICENSE file for terms.
+
+module MySQLExpectations
+  # An index field has a field name, length, and order (aka order)
+  #
+  class KeyField
+    attr_reader :name, :length, :order
+
+    ORDER_ASC = :asc
+    ORDER_DESC = :desc
+
+    VALID_ORDERINGS = [ORDER_ASC, ORDER_DESC]
+
+    def initialize(name, order = nil, length = nil)
+      @name = name
+      @order = validate_order(order)
+      @length = validate_length(length)
+    end
+
+    def ==(other)
+      other.name == @name && other.length == @length && other.order == @order
+    end
+
+    def to_s
+      "{ '#{name}', #{order_to_s}, #{length_to_s} }"
+    end
+
+    private
+
+    def order_to_s
+      return 'ASC' if order == ORDER_ASC
+      return 'DESC' if order == ORDER_DESC
+      'nil'
+    end
+
+    def length_to_s
+      length.to_s unless length.nil?
+      'nil'
+    end
+
+    def validate_length(length)
+      return nil if length.nil?
+      begin
+        length = Integer(length)
+      rescue ArgumentError
+        raise ArgumentError, 'length must be an integer or convertable to an integer'
+      end
+      length
+    end
+
+    def validate_order(order)
+      return nil if order.nil?
+      return order if VALID_ORDERINGS.include? order
+      fail ArgumentError, 'Order must be either KeyField::ORDER_ASC or KeyField::ORDER_DESC'
+    end
+  end
+end

data/lib/mysql_expectations/matchers/database_have_table.rb

@@ -0,0 +1,37 @@
+# Copyright (c) 2015 Yahoo Inc.
+# Copyrights licensed under the New BSD License.
+# See the accompanying LICENSE file for terms.
+
+module MySQLExpectations
+  module Matchers
+    # A matcher that checks a table's collation
+    #
+    class DatabaseHaveTable
+      attr_reader :expected_table, :database
+
+      def initialize(expected_table)
+        @expected_table = expected_table
+        @table = nil
+      end
+
+      def matches?(database)
+        @database = database
+        database.table?(expected_table)
+      end
+
+      def description
+        "have table '#{expected_table}'"
+      end
+
+      def failure_message
+        "expected '#{database.name}' database to have table " \
+          "'#{expected_table}'"
+      end
+
+      def failure_message_when_negated
+        "expected '#{database.name}' database not to have table " \
+          "'#{expected_table}'"
+      end
+    end
+  end
+end

data/lib/mysql_expectations/matchers/database_only_have_tables.rb

@@ -0,0 +1,68 @@
+# Copyright (c) 2015 Yahoo Inc.
+# Copyrights licensed under the New BSD License.
+# See the accompanying LICENSE file for terms.
+
+require 'mysql_expectations/array_refinements'
+
+module MySQLExpectations
+  module Matchers
+    # A matcher that checks what tables are in a database
+    #
+    class DatabaseOnlyHaveTables
+      using ArrayRefinements
+
+      attr_reader :database, :expected_table_names, :actual_table_names
+
+      def initialize(*expected_table_names)
+        @expected_table_names = expected_table_names.flatten
+        @database = nil
+      end
+
+      def liquibase_tables
+        %w(DATABASECHANGELOG DATABASECHANGELOGLOCK)
+      end
+
+      def actual_table_names
+        database.tables.map(&:name) - liquibase_tables
+      end
+
+      def matches?(database)
+        @database = database
+        actual_table_names.sort == expected_table_names.sort
+      end
+
+      def description
+        "only have tables #{expected_table_names.to_sentence}"
+      end
+
+      def additional_tables_message
+        message = ''
+        unless (actual_table_names - expected_table_names).empty?
+          message << ' but had additional tables: '
+          message <<
+            (actual_table_names - expected_table_names).to_sentence
+        end
+        message
+      end
+
+      def missing_tables_message
+        message = ''
+        unless (expected_table_names - actual_table_names).empty?
+          message << ' but was missing tables: '
+          message <<
+            (expected_table_names - actual_table_names).to_sentence
+        end
+        message
+      end
+
+      def failure_message
+        message = "expected '#{database.name}' "
+        message << 'database to only have tables '
+        message << expected_table_names.to_sentence
+        message << additional_tables_message
+        message << missing_tables_message
+        message
+      end
+    end
+  end
+end

data/lib/mysql_expectations/matchers/table_have_collation.rb

@@ -0,0 +1,36 @@
+# Copyright (c) 2015 Yahoo Inc.
+# Copyrights licensed under the New BSD License.
+# See the accompanying LICENSE file for terms.
+
+module MySQLExpectations
+  module Matchers
+    # A matcher that checks a table's collation
+    #
+    class TableHaveCollation
+      attr_reader :expected_collation, :table
+
+      def initialize(expected_collation)
+        @expected_collation = expected_collation
+        @table = nil
+      end
+
+      def actual_collation
+        table.collation
+      end
+
+      def matches?(table)
+        @table = table
+        actual_collation == expected_collation
+      end
+
+      def description
+        "have collation '#{expected_collation}'"
+      end
+
+      def failure_message
+        "expected '#{table.name}' table to have collation " \
+          "'#{expected_collation}' but it was '#{table.collation}'"
+      end
+    end
+  end
+end

data/lib/mysql_expectations/matchers/table_have_engine_type.rb

@@ -0,0 +1,37 @@
+# Copyright (c) 2015 Yahoo Inc.
+# Copyrights licensed under the New BSD License.
+# See the accompanying LICENSE file for terms.
+
+module MySQLExpectations
+  module Matchers
+    # A matcher that check a table's engine type
+    #
+    class HaveEngineType
+      attr_reader :expected_engine_type, :table
+
+      def initialize(expected_engine_type)
+        @expected_engine_type = expected_engine_type
+        @table = nil
+      end
+
+      def actual_engine_type
+        table.engine_type
+      end
+
+      def matches?(table)
+        @table = table
+        actual_engine_type == expected_engine_type
+      end
+
+      def description
+        "have engine type '#{expected_engine_type}'"
+      end
+
+      def failure_message
+        "expected '#{table.name}' table engine type to be " \
+          "'#{expected_engine_type}' " \
+          "but it was '#{actual_engine_type}'"
+      end
+    end
+  end
+end

data/lib/mysql_expectations/matchers/table_have_field.rb

@@ -0,0 +1,107 @@
+# Copyright (c) 2015 Yahoo Inc.
+# Copyrights licensed under the New BSD License.
+# See the accompanying LICENSE file for terms.
+
+module MySQLExpectations
+  module Matchers
+    # A matcher that checks if a MySQLDumpExpectations::Table has a field.
+    # Optionally, checks the field type and nullability
+    #
+    class HaveField
+      attr_reader :expected_field_name, :expected_type
+      attr_reader :expected_nullable, :table
+
+      def initialize(expected_field_name)
+        @expected_field_name = expected_field_name
+        @expected_type = nil
+        @expected_nullable = nil
+        @table = nil
+      end
+
+      def field_match?
+        table.field?(expected_field_name)
+      end
+
+      def actual_type
+        table.field(expected_field_name).type
+      end
+
+      def type_match?
+        if field_match? && !expected_type.nil?
+          return actual_type == expected_type
+        end
+        true
+      end
+
+      def actual_nullable
+        table.field(expected_field_name).nullable?
+      end
+
+      def nullable_match?
+        if field_match? && !expected_nullable.nil?
+          return actual_nullable == expected_nullable
+        end
+        true
+      end
+
+      def matches?(table)
+        @table = table
+        field_match? && type_match? && nullable_match?
+      end
+
+      def description
+        description = "have field '#{expected_field_name}'"
+        description << " of type '#{expected_type}'" if expected_type
+        description << ' that is nullable' if expected_nullable == true
+        description << ' that is not nullable' if expected_nullable == false
+        description
+      end
+
+      def field_error(negated: false)
+        "expected '#{table.name}' table" \
+          " #{negated ? 'not ' : ''}to "\
+          "have field '#{expected_field_name}'."
+      end
+
+      def type_error
+        "expected '#{table.name}.#{expected_field_name}' field " \
+          "to be of type '#{expected_type}' but it was '#{actual_type}'"
+      end
+
+      def nullable_error
+        message = "expected '#{table.name}.#{expected_field_name}' field "
+        message << 'to be '
+        message << 'not ' unless expected_nullable
+        message << 'nullable but it was '
+        message << 'not ' unless actual_nullable
+        message << 'nullable.'
+        message
+      end
+
+      def failure_message
+        return field_error unless field_match?
+        return type_error unless type_match?
+        return nullable_error unless nullable_match?
+      end
+
+      def failure_message_when_negated
+        field_error(negated: true)
+      end
+
+      def of_type(expected_type)
+        @expected_type = expected_type
+        self
+      end
+
+      def that_is_nullable
+        @expected_nullable = true
+        self
+      end
+
+      def that_is_not_nullable
+        @expected_nullable = false
+        self
+      end
+    end
+  end
+end

data/lib/mysql_expectations/matchers/table_have_key.rb

@@ -0,0 +1,52 @@
+# Copyright (c) 2015 Yahoo Inc.
+# Copyrights licensed under the New BSD License.
+# See the accompanying LICENSE file for terms.
+
+module MySQLExpectations
+  module Matchers
+    # A matcher that checks if a MySQLDumpExpectations::Table has a field.
+    # Optionally, checks the field type and nullability
+    #
+    class HaveKey
+      attr_reader :expected_key, :table
+
+      def initialize(expected_key)
+        @expected_key = expected_key
+        @table = nil
+      end
+
+      def matches?(table)
+        @table = table
+        @table.key?(expected_key.name) &&
+          @table.key(expected_key.name) == expected_key
+      end
+
+      def description
+        description = "have key #{expected_key}"
+        description
+      end
+
+      def current_keys(keys)
+        result = ''
+        keys.each_with_index do |key, index|
+          result << key.to_s
+          result << ",\n" unless index == keys.size - 1
+        end
+        result
+      end
+
+      def failure_message
+        result = "expected '#{table.name}' table to " \
+          "have key #{expected_key}"
+        keys = table.keys
+        if keys.empty?
+          result << ' but it has no keys.'
+        else
+          result << " but it has keys:\n"
+          result << current_keys(keys)
+        end
+        result
+      end
+    end
+  end
+end

data/lib/mysql_expectations/matchers.rb

@@ -0,0 +1,50 @@
+# Copyright (c) 2015 Yahoo Inc.
+# Copyrights licensed under the New BSD License.
+# See the accompanying LICENSE file for terms.
+
+require 'mysql_expectations/matchers/database_have_table'
+require 'mysql_expectations/matchers/database_only_have_tables'
+require 'mysql_expectations/matchers/table_have_collation'
+require 'mysql_expectations/matchers/table_have_engine_type'
+require 'mysql_expectations/matchers/table_have_field'
+require 'mysql_expectations/matchers/table_have_key'
+
+# rubocop:disable Style/PredicateName
+
+module MySQLExpectations
+  # Allows assertions on a database
+  #
+  module Matchers
+    ####################
+    # Database Matchers
+    ####################
+
+    def have_table(expected_table_name)
+      DatabaseHaveTable.new(expected_table_name)
+    end
+
+    def only_have_tables(*expected_table_names)
+      DatabaseOnlyHaveTables.new(*expected_table_names)
+    end
+
+    ####################
+    # Table Matchers
+    ####################
+
+    def have_collation(expected_collation)
+      TableHaveCollation.new(expected_collation)
+    end
+
+    def have_engine_type(expected_engine_type)
+      HaveEngineType.new(expected_engine_type)
+    end
+
+    def have_field(expected_field_name)
+      HaveField.new(expected_field_name)
+    end
+
+    def have_key(expected_key)
+      HaveKey.new(expected_key)
+    end
+  end
+end

data/lib/mysql_expectations/mysql.rb

@@ -0,0 +1,55 @@
+# Copyright (c) 2015 Yahoo Inc.
+# Copyrights licensed under the New BSD License.
+# See the accompanying LICENSE file for terms.
+
+require 'rexml/document'
+require 'mysql_expectations/database'
+
+module MySQLExpectations
+  # The database_structure_file should be an XML file resulting from the
+  # mysqldump command:
+  #
+  # mysqldump --xml --no-data --all-databases \
+  #   --host=#{env.host} --port=#{env.port} \
+  #   --user=#{env.username}
+  #
+  class MySQL
+    def initialize(source)
+      @doc = REXML::Document.new(source)
+    end
+
+    def database?(name)
+      query = "mysqldump/database[@name='#{name}']"
+      !@doc.elements[query].nil?
+    end
+
+    alias_method :has_database?, :database?
+
+    def database(name)
+      query = "mysqldump/database[@name='#{name}']"
+      database_element = @doc.elements[query]
+      Database.new database_element if database_element
+    end
+
+    def databases
+      query = 'mysqldump/database'
+      databases = []
+      @doc.elements.each(query) do |database_element|
+        databases << Database.new(database_element)
+      end
+      databases
+    end
+
+    def method_missing(method_sym, *arguments, &block)
+      if arguments.empty? && block.nil?
+        database_name = method_sym.to_s
+        return database(database_name) if database?(database_name)
+      end
+      super
+    end
+
+    def respond_to_missing?(method, *)
+      database?(method.to_s) || super
+    end
+  end
+end

data/lib/mysql_expectations/table.rb

@@ -0,0 +1,102 @@
+# Copyright (c) 2015 Yahoo Inc.
+# Copyrights licensed under the New BSD License.
+# See the accompanying LICENSE file for terms.
+
+require 'mysql_expectations/field'
+require 'mysql_expectations/key'
+
+module MySQLExpectations
+  # Allows assertions on a table
+  #
+  class Table
+    def initialize(table_element)
+      @table_element = table_element
+    end
+
+    def name
+      @table_element.attributes['name']
+    end
+
+    def field?(expected_field)
+      query =  "field[@Field='#{expected_field}']"
+      !@table_element.elements[query].nil?
+    end
+
+    alias_method :has_field?, :field?
+
+    def field(name)
+      query = "field[@Field='#{name}']"
+      field_element = @table_element.elements[query]
+      Field.new field_element if field_element
+    end
+
+    def fields
+      query = 'field'
+      fields = []
+      @table_element.elements.each(query) do |field_element|
+        fields << Field.new(field_element)
+      end
+      fields
+    end
+
+    def option?(expected_options)
+      options = @table_element.elements['options']
+      expected_options.each do |expected_key, expected_value|
+        value = options.attributes[expected_key]
+        return false if value.nil? || value != expected_value
+      end
+    end
+
+    alias_method :has_option?, :option?
+
+    def engine_type
+      options = @table_element.elements['options']
+      options.attributes['Engine'] if options
+    end
+
+    def engine_type?(expected_engine_type)
+      engine_type == expected_engine_type
+    end
+
+    alias_method :has_engine_type?, :engine_type?
+
+    def collation
+      options = @table_element.elements['options']
+      options.attributes['Collation'] if options
+    end
+
+    def collation?(expected_collation)
+      collation == expected_collation
+    end
+
+    alias_method :has_collation?, :collation?
+
+    def key?(key_name)
+      Key.key?(@table_element, key_name)
+    end
+
+    def primary_key?
+      key?('PRIMARY')
+    end
+
+    def key(key_name)
+      Key.load_key(@table_element, key_name)
+    end
+
+    def keys
+      Key.load_all_keys(@table_element)
+    end
+
+    def method_missing(method, *arguments, &block)
+      if arguments.empty? && block.nil?
+        name = method.to_s
+        return field(name) if field?(name)
+      end
+      super
+    end
+
+    def respond_to_missing?(method, *)
+      field?(method.to_s) || super
+    end
+  end
+end

data/lib/mysql_expectations/version.rb

@@ -0,0 +1,10 @@
+# Copyright (c) 2015 Yahoo Inc.
+# Copyrights licensed under the New BSD License.
+# See the accompanying LICENSE file for terms.
+
+module MySQLExpectations
+  # This module holds the gem version number used in the gemspec
+  module Version
+    VERSION = '1.0.0'
+  end
+end

data/lib/mysql_expectations.rb

@@ -0,0 +1,19 @@
+# Copyright (c) 2015 Yahoo Inc.
+# Copyrights licensed under the New BSD License.
+# See the accompanying LICENSE file for terms.
+
+require 'mysql_expectations/array_refinements'
+require 'mysql_expectations/mysql'
+require 'mysql_expectations/database'
+require 'mysql_expectations/table'
+require 'mysql_expectations/field'
+require 'mysql_expectations/key'
+require 'mysql_expectations/key_field'
+require 'mysql_expectations/matchers'
+require 'mysql_expectations/version'
+
+require 'rspec'
+
+RSpec.configure do |config|
+  config.include MySQLExpectations::Matchers
+end

metadata

@@ -0,0 +1,201 @@
+--- !ruby/object:Gem::Specification
+name: mysql_expectations
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- James Couball
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-06-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: mustache
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: rspec-collection_matchers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: cucumber
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: aruba
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: relish
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.4'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ! "    The mysql_expectations gem allows you to make RSpec expectations\n
+  \   on the schemas and data in a MySQL database enabling test first\n    development
+  and more confident Continuous Delivery.\n"
+email: couballj@yahoo-inc.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/mysql_expectations.rb
+- lib/mysql_expectations/array_refinements.rb
+- lib/mysql_expectations/database.rb
+- lib/mysql_expectations/field.rb
+- lib/mysql_expectations/key.rb
+- lib/mysql_expectations/key_field.rb
+- lib/mysql_expectations/matchers.rb
+- lib/mysql_expectations/matchers/database_have_table.rb
+- lib/mysql_expectations/matchers/database_only_have_tables.rb
+- lib/mysql_expectations/matchers/table_have_collation.rb
+- lib/mysql_expectations/matchers/table_have_engine_type.rb
+- lib/mysql_expectations/matchers/table_have_field.rb
+- lib/mysql_expectations/matchers/table_have_key.rb
+- lib/mysql_expectations/mysql.rb
+- lib/mysql_expectations/table.rb
+- lib/mysql_expectations/version.rb
+homepage: https://github.com/yahoo/mysql_expectations
+licenses:
+- BSD-3-Clause
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: RSpec matchers for MySQL schemas and data
+test_files: []