rspec-active_record_mocks 0.1.4 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7916c465a0bd34487754d11b36daec7aa98b6bf7
-  data.tar.gz: 08aed740399bf1acc91fb9f8667eac66590ed2d8
+  metadata.gz: 6e35438d49c6384a1ff0f6f50e20be1d24ba5275
+  data.tar.gz: 3647113e60f410c852aa188b5b960b6a29a4acf2
 SHA512:
-  metadata.gz: b0ebb4c40c62875ab92a27619f1427a770de89d87c8b5b757f10d8deb6cffe033f40bd6e70d7d6514a926e4f867e6901f6f0a03ab2cfe849542796e1925aeb64
-  data.tar.gz: 1a7786439a49a411e9d1c4041797ef1e3aaadd9caeed8b8404be76c87e9917ff2d7ac2491b49613fb7b460cc2e6387bf10585c9de3dfe2ee1963efcb65924571
+  metadata.gz: 96ff970256537da82849bc5812e57da8ad3b7ffa7acff26deefeac9c773cc925097c7d025f9adabe68d330b363e50200fb6a62e3838ee7e600059ea07eacad7a
+  data.tar.gz: d3a6e82279c6eacf1aef4cdc8e6b7cedcb65e12d1e179fb9b5c449669aa0662f9b45cd8c8af3c054fc5860039327ea9e88cef48363b3ea0ed5a23a03253d76d1

data/Gemfile

@@ -1,5 +1,5 @@
 source "https://rubygems.org"
-gemspec
+gemspec :name => "Gem1"
 
 group :development do
   unless ENV["CI"]

data/Readme.md

@@ -1,114 +1,148 @@
-# Important note
-
-*Over the next few days this gem will be transformed to simply be
-`active_record_mocks` so it works with Test::Unit, MiniTest and RSpec.
-This gem will be a complete alias of the other one and will still be
-published but your work flow might change a bit depending on how I
-decide to go about the work flow, this means that you could end up
-using it in an entirely different way than before.*
-
-# RSpec Active Record Mocks.
+# Active Record Mocks.
 
 [![Build Status](https://travis-ci.org/envygeeks/active_record_mocks.png?branch=master)](https://travis-ci.org/envygeeks/active_record_mocks) [![Coverage Status](https://coveralls.io/repos/envygeeks/active_record_mocks/badge.png?branch=master)](https://coveralls.io/r/envygeeks/active_record_mocks) [![Code Climate](https://codeclimate.com/github/envygeeks/active_record_mocks.png)](https://codeclimate.com/github/envygeeks/active_record_mocks) [![Dependency Status](https://gemnasium.com/envygeeks/active_record_mocks.png)](https://gemnasium.com/envygeeks/active_record_mocks)
 
 ActiveRecord Mocks is designed to aide you in testing your ActiveRecord
 concerns by creating random models (or even named models) that are
-removed after each test.
+removed after each test.  It was originally concieved to test concerns,
+includes and other types of things that normally aren't tied to a
+model specifically.
 
 ## Installing
 
 ```ruby
-gem "rspec-active_record_mocks"
+gem "active_record_mocks"
 ```
 
 ## Using
 
-`RSpec::ActiveRecordMocks` supports `before` with `:all` or `:each`, it
-can also be used directly inside the it.  It's designed to try and be a
-little bit flexible in how you try to use it.
-
 ```ruby
+with_mocked_tables do |m|
+  m.enable_extension "uuid-ossp"
+  m.enable_extension "hstore"
 
-# ----------------------------------------------------------------------------
-# One Line Usage.
-# ----------------------------------------------------------------------------
+  t1 = m.create_table do |t|
+    t.model_name :Foo
+    t.belongs_to :bar
 
-describe TestConcern do
-  it "should work as expected" do
-    expect(mock_active_record_model(:include => TestConcern).test_column).to eq "value"
+    t.layout do |l|
+       l.integer :bar_id
+    end
   end
+
+  t2 = m.create_table do |t|
+    t.model_name :Bar
+    t.has_many   :foo
+
+    t.layout do |l|
+      l.text :bar_text
+    end
+  end
+
+  # Do Work Here
 end
 ```
 
-```ruby
+---
 
-# ----------------------------------------------------------------------------
-# An example using extensions!
-# ----------------------------------------------------------------------------
+### Extensions
 
-describe TestConcern do
-  it "should work with extensions" do
-    mock_active_record_model(:extensions => :hstore)
-    expect(ActiveRecord::Base.connection.extensions).to include "hstore"
-  end
+You can enable PostgreSQL extensions inside of your models using the
+`enable_extension` method when inside of `with_mocked_tables` or
+`with_mocked_models` like so:
+
+```ruby
+with_mocked_tables do |m|
+  m.enable_extension "extension-name"
 end
 ```
 
-```ruby
+---
 
-# ----------------------------------------------------------------------------
-# Before :all example with :include and a migration.
-# Also works with `before :each`
-# ----------------------------------------------------------------------------
+### Creating Tables and Layouts
 
-describe TestConcern do
-  before :all do
-    @test_model = mock_active_record_model(:include => TestConcern) do
-      table.string(:test_column)
-    end
-  end
+To create tables you use the `create_table` method when inside of
+`with_mocked_tables` or `with_mocked_models`, like so:
 
-  it "should have the concerns method" do
-    expect(@test_model.new).to respond_to :test_method
+```ruby
+with_mocked_tables do |m|
+  m.create_table migration_arguments do |t|
+    t.layout do |l|
+      l.text :foo_text
+    end
   end
 end
 ```
 
-```ruby
+#### Belongs to, Has Many and other methods
 
-# ----------------------------------------------------------------------------
-# Before :all example that does a class_eval to include.
-# Also works with `before :each`
-# ----------------------------------------------------------------------------
+Any method that `ActiveRecordMocks` does not know or understand is
+passed on to the model itself, so if you need for example `belongs_to`
+then you would simply use belongs to when creating your table:
 
-describe TestConcern do
-  before :all do
-    @model = mock_active_record_model.class_eval do
-      include MyActiveRecordConcern
+```ruby
+with_mocked_tables do |m|
+  m.create_table migration_arguments do |t|
+    t.belongs_to :bar_model
+    t.layout do |l|
+      l.text :foo_text
     end
   end
+end
+```
 
-  it "should work" do
-    expect(@model.concern_method).to eq "concern_value"
+#### Named models and tables
+
+If you need a named model or a named table or a model whose table is
+different than it's model you can use the methods `model_name` and
+`table_name`, if you simply need a named model and you use standard
+naming conventions than you can simply leave out the `table_name`
+when using model name and `ActiveRecordMocks` will tabelize the name
+of your model automatically the same as `Rails` would.
+
+```ruby
+with_mocked_tables do |m|
+  t1 = m.create_table migration_arguments do |t|
+    t.model_name :Foo
+    t.layout do |l|
+      l.text :foo_text
+    end
   end
 end
+
+# Results in:
+#   - Foo  (Model)
+#   - foos (Table)
 ```
 
 ```ruby
+with_mocked_tables do |m|
+  t1 = m.create_table migration_arguments do |t|
+    t.table_name :old_foo
+    t.model_name :Foo
+    t.layout do |l|
+      l.text :foo_text
+    end
+  end
+end
 
-# ----------------------------------------------------------------------------
-# Completely random example in a before :all.
-# Also works with `before :each`
-# ----------------------------------------------------------------------------
+# Results in:
+#   - Foo      (Model)
+#   - old_foo  (Table)
+```
 
-describe MyActiveRecordConcern do
-  before :all do
-    @model = mock_active_record_model do |table|
-      table.string(:column)
-    end
+#### Model Includes
 
-    @model.class_eval do
-      include MyActiveRecordConcern
+If you need to include anything into your model you can use the
+`includes` method when inside of `with_mocked_models` or
+`with_mocked_tables`, like so:
+
+```ruby
+with_mocked_tables do |m|
+  m.create_table migration_arguments do |t|
+    t.includes Bar1, Bar2
+    t.layout do |l|
+      l.text :foo_text
     end
   end
 end

data/lib/active_record_mocks.rb

@@ -0,0 +1,21 @@
+require "active_record"
+
+module ActiveRecordMocks
+  require_relative "active_record_mocks/mock"
+
+  module IncludeMe
+    def mocked_active_record
+      Mock.new
+    end
+
+    def with_mocked_tables(&block)
+      if block_given?
+        mocked_active_record.tap do |o|
+          block.call(o)
+          o.delete_tables
+        end
+      end
+    nil
+    end
+  end
+end

data/lib/active_record_mocks/mock.rb

@@ -0,0 +1,55 @@
+require_relative "mock/table"
+require "active_record"
+
+module ActiveRecordMocks
+  class Mock
+    class ExtensionsUnsupported < StandardError
+      def initialize
+        super "Your database server does not support extensions."
+      end
+    end
+
+    attr_accessor :tables
+
+    def enable_extension(ext)
+      raise_if_extensions_unsupported!
+      ActiveRecord::Migration.tap do |o|
+        o.suppress_messages do
+          o.enable_extension(ext)
+        end
+      end
+    end
+
+    def create_table(*args, &block)
+      Table.new(*args).tap do |o|
+        if block_given?
+          block.call(o)
+        end
+
+        o.setup_mocking!
+        tables.push(o)
+        return o.model
+      end
+    end
+
+    def initialize
+      @tables = [
+      ]
+    end
+
+    def delete_tables
+      tables.each do |t|
+        Object.send(:remove_const, t.model_name)
+        ActiveRecord::Base.connection.drop_table(t.table_name)
+      end
+    nil
+    end
+
+    private
+    def raise_if_extensions_unsupported!
+      if ! ActiveRecord::Base.connection.respond_to?(:enable_extension)
+        raise ExtensionsUnsupported
+      end
+    end
+  end
+end

data/lib/active_record_mocks/mock/table.rb

@@ -0,0 +1,148 @@
+require "active_support/core_ext/string/inflections"
+
+module ActiveRecordMocks
+  class Mock
+    class Table
+      attr_reader :model_methods
+      attr_reader :args
+
+      def initialize(*args, &block)
+        @model_methods = []
+        @table_name = nil
+        @includes = []
+        @args = args
+        @layout = nil
+        @model_name = nil
+      end
+
+      # ---------------------------------------------------------------
+      # Tells us if we have already setup this model and object so
+      # that we don't keep setting stuff up.
+      # ---------------------------------------------------------------
+
+      def setup?
+        @already_setup ? true : false
+      end
+
+      # ---------------------------------------------------------------
+      # Gives the proper object of the model for you.
+      # ---------------------------------------------------------------
+
+      def model
+        if setup?
+          Object.const_get(@model_name)
+        end
+      end
+
+      # ---------------------------------------------------------------
+      # Allows you to set the files that should be included into the
+      # model, you must use t.includes because t.include is already
+      # a method on the object you are in.
+      # ---------------------------------------------------------------
+
+      def includes(*incs)
+        if setup? || incs.size == 0
+          @includes
+        else
+          incs.each do |i|
+            unless i.blank?
+              @includes.push(i)
+            end
+          end
+        end
+      end
+
+      # ---------------------------------------------------------------
+      # Allows you to set the layout for the table you are building.
+      # ---------------------------------------------------------------
+
+      def layout(&block)
+        setup? || ! block_given? ? @layout ||= nil : @layout = block
+      end
+
+      # ---------------------------------------------------------------
+      # Allows the setting of or setuping up of and returning of the
+      # name of the table that is being used for the model.  If
+      # you do not customize this then it will be a tabelized name
+      # of the model, the same way that normal active_record would do.
+      # ---------------------------------------------------------------
+
+      def table_name(tname = nil)
+        if setup? || (! tname && @table_name)
+          @table_name
+        else
+          @table_name = \
+            tname ? tname : model_name.to_s.tableize
+        end
+      end
+
+      # ---------------------------------------------------------------
+      # Allows for the setting of or setup of and returning of the name
+      # of the model being used, this should not be confused with model
+      # which returns the actual object.  The model need not match the
+      # table and sometimes it won't if you chose to be that way.
+      # ---------------------------------------------------------------
+
+      def model_name(mname = nil)
+        if setup? || (! mname && @model_name)
+          @model_name
+        else
+          @model_name = mname ? mname : \
+            SecureRandom.hex(10).tr("^a-z", "").capitalize
+        end
+      end
+
+      def setup_mocking!
+        if ! setup?
+          setup_table!
+          setup_model!
+          @already_setup = true
+        end
+      end
+
+      private
+      def setup_table!
+        ActiveRecord::Migration.tap do |o|
+          o.suppress_messages do
+            o.create_table table_name, *args do |t|
+              layout.call(t) if layout.is_a?(Proc)
+            end
+          end
+        end
+      end
+
+      private
+      def setup_model!
+        Object.const_set(model_name,
+            Class.new(ActiveRecord::Base)).tap do |o|
+          o.table_name = table_name
+          setup_includes(o)
+          run_model_methods(o)
+        end
+      end
+
+      private
+      def setup_includes(obj)
+        includes.each do |i|
+          obj.send(:include, i)
+        end
+      end
+
+      private
+      def run_model_methods(obj)
+        model_methods.each do |m|
+          obj.send(m[:method], *m[:args], &m[:block])
+        end
+      end
+
+      public
+      def method_missing(methud, *args, &block)
+        model_methods.push({
+          :block => block,
+          :method => methud,
+          :args => args
+        })
+      end
+    end
+  end
+end

data/lib/active_record_mocks/rails.rb

@@ -0,0 +1,5 @@
+require_relative "../active_record_mocks"
+
+class ActiveSupport::TestCase
+  include ActiveRecordMocks::IncludeMe
+end

data/lib/active_record_mocks/rspec.rb

@@ -0,0 +1,6 @@
+require_relative "../active_record_mocks"
+require "rspec"
+
+RSpec.configure do |config|
+  config.include ActiveRecordMocks::IncludeMe
+end

data/lib/active_record_mocks/version.rb

@@ -0,0 +1,3 @@
+module ActiveRecordMocks
+  VERSION = "1.0.0"
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rspec-active_record_mocks
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 1.0.0
 platform: ruby
 authors:
 - Jordon Bedwell
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-22 00:00:00.000000000 Z
+date: 2013-09-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -102,9 +102,13 @@ files:
 - License
 - Rakefile
 - Gemfile
-- lib/rspec/active_record_mocks.rb
-- lib/rspec/active_record_mocks/version.rb
-homepage: https://github.com/envygeeks/rspec-active_record_mocks
+- lib/active_record_mocks.rb
+- lib/active_record_mocks/rails.rb
+- lib/active_record_mocks/version.rb
+- lib/active_record_mocks/mock/table.rb
+- lib/active_record_mocks/mock.rb
+- lib/active_record_mocks/rspec.rb
+homepage: https://github.com/envygeeks/active_record_mocks
 licenses:
 - Apache 2.0
 metadata: {}

data/lib/rspec/active_record_mocks.rb

@@ -1,98 +0,0 @@
-require "active_support/core_ext/string/inflections"
-require "active_record"
-require "rspec"
-
-module RSpec
-  module ActiveRecordMocks
-    class ExtensionsUnsupportedError < StandardError
-      def initialize
-        super "Your adapter does not support PostgreSQL extensions"
-      end
-    end
-
-    # Allow people to mock ActiveRecord while giving them the flexibility.
-
-    def mock_active_record_model(opts = {}, &block)
-      tbl, ext = opts.delete(:name), opts.delete(:extensions)
-      tbl = create_active_record_table_for_mocking(tbl, ext, &block)
-      Object.const_set(tbl.camelize, Class.new(ActiveRecord::Base)).class_eval do
-        include opts.delete(:include) if opts[:include]
-        self.table_name = tbl and self
-      end
-    end
-
-    # Roll through each one of the created tables and destroy them.
-
-    def clean_tables_for_active_record_mocking
-      if mocked_active_record_options[:mocked_active_record_tables]
-        mocked_active_record_options.delete(:mocked_active_record_tables).each do |tbl|
-          ActiveRecord::Base.connection.drop_table(tbl) if active_record_tables.include?(tbl)
-          if Object.const_defined?(tbl.camelize)
-            Object.send(:remove_const, tbl.camelize)
-          end
-        end
-      end
-    end
-
-    # Aliases ActiveRecord::Base.connection.tables to active_record_tables to
-    # a geniunely useful method that can be used by anybody doing db testing.
-
-    def active_record_tables
-      ActiveRecord::Base.connection.tables
-    end
-
-    # Allows us to access options for either the class or the test itself as
-    # to allow users to either work on the class or work in the test allowing
-    # us to cleanup without affecting the other.
-
-    private
-    def mocked_active_record_options
-      (example.nil?) ? (@mocked_active_record_options ||= {}) : example.options
-    end
-
-    # Creates a temporary table inside of the database using ActiveRecord.
-
-    private
-    def create_active_record_table_for_mocking(tbl, ext, &block)
-      tbl = (tbl || SecureRandom.hex(30).tr('^a-z', '')).to_s
-      setup_active_record_mocking_table(tbl, ext, &block)
-      tbl
-    end
-
-    # Sets up the table using an ActiveRecord migration.
-
-    private
-    def setup_active_record_mocking_table(tbl, ext, &block)
-      (mocked_active_record_options[:mocked_active_record_tables] ||= []).push(tbl)
-      ActiveRecord::Migration.suppress_messages do
-        setup_active_record_mocking_extensions(ext)
-        ActiveRecord::Migration.create_table tbl do |obj|
-          block.call(obj) if block_given?
-        end
-      end
-    end
-
-    # Sets up the extensions for PostgreSQL.
-
-    private
-    def setup_active_record_mocking_extensions(ext)
-      ext = [ext].delete_if { |value| value.blank? }.flatten
-      if ext.size > 0 && ! ActiveRecord::Base.connection.respond_to?(:enable_extension)
-        raise ExtensionsUnsupportedError
-      else
-        ext.each do |extension|
-          ActiveRecord::Migration.enable_extension(extension)
-        end
-      end
-    end
-  end
-end
-
-RSpec.configure do |config|
-  config.include RSpec::ActiveRecordMocks
-  [:all, :each].each do |type|
-    config.after(type) do
-      clean_tables_for_active_record_mocking
-    end
-  end
-end

data/lib/rspec/active_record_mocks/version.rb

@@ -1,5 +0,0 @@
-module RSpec
-  module ActiveRecordMocks
-    VERSION = "0.1.4"
-  end
-end