imitate 0.1.6 → 0.2.0

data/.rspec

@@ -1 +1,2 @@
 --color
+--format documentation

data/VERSION

@@ -1 +1 @@
-0.1.6
+0.2.0

data/imitate.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = "imitate"
-  s.version = "0.1.6"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Petr Janda", "Pericles Dias"]

data/lib/imitate.rb

@@ -23,9 +23,9 @@ module Imitate
     # @param [Proc] Optional block to be instance evaluated on new class.
     #
     def mock(name, &block)
-      process_name(name) {|parent, token, leaf|
-        leaf ? create_const(Class, parent, token, &block) : create_const(Module, parent, token)
-      }
+      process_name(name) do |parent, token, leaf|
+        leaf ? create_class_const(parent, token, &block) : create_module_const(parent, token)
+      end
     end
 
     #
@@ -35,9 +35,9 @@ module Imitate
     # @param [String] Name of the class to be removed.
     #
     def unmock(name)
-      process_name(name) {|parent, token|
-        self.send(was_mocked?(parent, token) ? :remove_mock : :get_const, parent, token)
-      }
+      process_name(name) do |parent, token|
+        self.send((was_mocked?(parent, token) ? :remove_mock : :get_const), parent, token)
+      end
     end
 
     #
@@ -45,29 +45,28 @@ module Imitate
     # way then using Imitate.
     #
     def unmock_all
-      while mock = MOCKED.shift
-        remove_mock(mock[:parent], mock[:name])
+      MOCKED.slice!(0..-1).each do |mock|
+        remove_mock mock[:parent], mock[:name]
       end
     end
 
     private 
 
     def process_name(name)
-      tokens = name.split('::')
+      tokens = name.split '::'
       parent = Object
 
-      while token = tokens.shift
-        parent = yield(parent, token, tokens.length == 0)
-      end
+      tokens[0..-2].each {|token| parent = yield(parent, token, false) }
+      yield parent, tokens[-1], true
     end
 
     def was_mocked?(parent, name)
-      MOCKED.index({:parent => parent, :name => name})
+      MOCKED.index :parent => parent, :name => name
     end
 
     def remove_mock(parent, name)
-      MOCKED.delete({:parent => parent, :name => name})
-      remove_const(parent, name)
+      MOCKED.delete :parent => parent, :name => name
+      remove_const parent, name
     end
 
     def remove_const(parent, name)
@@ -75,20 +74,26 @@ module Imitate
     end
 
     def get_const(parent, name)
-        parent.const_get(name)
+        parent.const_get name
       rescue
         nil
     end
 
-    def create_const(clazz, parent, name, &block)
+    def create_class_const(parent, name, &block)
+      create_const(parent, name) { Class.new(&block) }
+    end
+
+    def create_module_const(parent, name)
+      create_const(parent, name) { Module.new }
+    end
+
+    def create_const(parent, name)
       begin
         parent.const_get name
       rescue
-        clazz_instance = clazz.new(&block)
-
         MOCKED << {:parent => parent, :name => name}
 
-        parent.const_set name, clazz_instance
+        parent.const_set name, yield
       end
     end
   end

data/spec/imitate_spec.rb

@@ -1,134 +1,372 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
-describe "Imitate" do
+describe Imitate do
 
-  describe '.unmock_all' do
-    it 'should remove all mocked objects' do
-      Imitate.mock('Foo')
-      Imitate.mock('Bar')
+  module FooModule
+    def self.not_an_imitation; end
 
-      Foo.should be
-      Bar.should be
+    class FooClass; end
+    
+    module BarModule
+      class BarClass; end
+    end
+  end
+
+  describe '.mock' do
+    context 'when const does not exist' do
+      context 'for a simple class' do
+        before { Imitate.mock 'Foo' }
+
+        after { Imitate.unmock 'Foo' }
+
+        it 'should create new dummy class' do
+          Foo.should be
+          Foo.class.should be Class
+        end
+      end
+
+      context 'for a class with a block' do
+        before do
+          Imitate.mock('Foo') do
+            def bar
+              'bar'
+            end
+          end
+        end
+
+        after { Imitate.unmock 'Foo' }
+
+        it 'should instance evaluate given block' do
+          Foo.new.should respond_to :bar
+          Foo.new.bar.should == 'bar'
+        end
+      end
+
+      context 'for a namespaced class' do
+        before { Imitate.mock 'Foo::Bar' }
+        after { Imitate.unmock 'Foo::Bar' }
+
+        it 'should create necessary namespace' do
+          Foo.should be
+          Foo.class.should be Module
+        end
+
+        it 'should create namespaced class' do
+          Foo::Bar.should be
+          Foo::Bar.class.should be Class
+        end
+      end
 
-      Imitate.unmock_all
+      context 'for a deeply namespaced class' do
+        before { Imitate.mock 'Foo::Bar::Baz' }
+        after { Imitate.unmock 'Foo::Bar::Baz' }
 
-      lambda { Foo }.should raise_error
-      lambda { Bar }.should raise_error
+        it 'should create necessary namespace' do
+          Foo.should be
+          Foo.class.should be Module
+        end
+
+        it 'should create necessary namespace' do
+          Foo::Bar.should be
+          Foo::Bar.class.should be Module
+        end
+
+        it 'should create namespaced class' do
+          Foo::Bar::Baz.should be
+          Foo::Bar::Baz.class.should be Class
+        end
+      end
+    end
+
+    context 'when const exists' do
+      context 'for a simple class' do
+        before { Imitate.mock 'FooModule' }
+
+        it 'should not override already existing object' do
+          FooModule.class.should be Module
+          FooModule.should respond_to :not_an_imitation
+        end
+      end
+
+      context 'for a namespaced class' do
+        before { Imitate.mock 'FooModule::Foo' }
+        after { Imitate.unmock 'FooModule::Foo' }
+
+        it 'should not override already existing object' do
+          FooModule.class.should be Module
+          FooModule.should respond_to :not_an_imitation
+        end
+
+        it 'should create namespaced class' do
+          FooModule::Foo.should be
+          FooModule::Foo.class.should be Class
+        end
+      end
+
+      context 'for a deeply namespaced class' do
+        before { Imitate.mock 'FooModule::Foo::Bar' }
+        after { Imitate.unmock 'FooModule::Foo::Bar' }
+
+        it 'should not override already existing object' do
+          FooModule.class.should be Module
+          FooModule.should respond_to :not_an_imitation
+        end
+
+        it 'should create necessary namespace' do
+          FooModule::Foo.should be
+          FooModule::Foo.class.should be Module
+        end
+
+        it 'should create namespaced class' do
+          FooModule::Foo::Bar.should be
+          FooModule::Foo::Bar.class.should be Class
+        end
+      end
     end
   end
 
   describe '.unmock' do
-    context 'const exists' do
-      context 'const was mocked by imitate' do
-        it 'should remove the class' do
-          Imitate.mock('Foo')
-          Imitate.unmock('Foo')
+    context 'when class does not exist' do
+      it 'should do nothing' do
+        Imitate.unmock 'Foo'
 
-          lambda { Object.const_get('Foo') }.should raise_error
-        end
+        Imitate.expects(:remove_const).never
+      end
+    end
 
-        it 'should remove the class and namespaces' do
-          Imitate.mock('Foo::Bar')
-          Imitate.unmock('Foo::Bar')
+    context 'without namespaces' do
+      context 'when const was not mocked' do
+        it 'should do nothing' do
+          Imitate.unmock 'FooModule'
 
-          lambda { Foo::Bar }.should raise_error
-          lambda { Foo }.should raise_error
+          FooModule.should be
         end
+      end
 
-        it 'should remove record from MOCKED' do
-          Imitate.mock('Foo')
-          Imitate.unmock('Foo')
+      context 'when const was mocked' do
+        before { Imitate.mock 'Foo' }
 
-          Imitate.expects(:remove_const).never
+        it 'should remove the mocked object' do
+          Imitate.unmock 'Foo'
 
-          Imitate.unmock('Foo')
+          expect { ::Foo }.to raise_error NameError, 'uninitialized constant Foo'
         end
       end
+    end
+
+    context 'with namespaces' do
+      context 'when const was not mocked' do
+        it 'should do nothing' do
+          Imitate.unmock 'FooModule::FooClass'
 
-      context 'if const was not mocked' do
-        before {
-          class Foo1
+          FooModule::FooClass.should be
+        end
+      end
+
+      context 'when const was mocked' do
+        context 'when no namespace exist' do
+          before { Imitate.mock 'Foo::Bar' }
+          
+          it 'should remove the mocked object' do
+            Imitate.unmock 'Foo::Bar'
+
+            expect { ::Foo }.to raise_error NameError, 'uninitialized constant Foo'
+            expect { ::Foo::Bar }.to raise_error NameError, 'uninitialized constant Foo'
           end
-        }
+        end
 
-        after { Object.instance_eval { remove_const 'Foo1' } }
+        context 'when namespaces already exist' do
+          before { Imitate.mock 'FooModule::Foo' }
+          
+          it 'should remove the mocked object' do
+            Imitate.unmock 'FooModule::Foo'
 
+            FooModule.should be
+            expect { ::FooModule::Foo }.to raise_error NameError, 'uninitialized constant FooModule::Foo'
+          end
+        end
+      end
+    end
+
+    context 'with deep namespaces' do
+      context 'when const was not mocked' do
         it 'should do nothing' do
-          Imitate.unmock('Foo1')
+          Imitate.unmock 'FooModule::BarModule::BarClass'
 
-          Foo1.should be
+          FooModule::BarModule::BarClass.should be
         end
       end
 
-      context 'if class was not mocked in existing module' do
-        before {
-          module Module1
+      context 'when const was mocked' do
+        context 'when no namespace exist' do
+          before { Imitate.mock 'Foo::Bar::Baz' }
+          
+          it 'should remove the mocked object' do
+            Imitate.unmock 'Foo::Bar::Baz'
+
+            expect { ::Foo }.to raise_error NameError, 'uninitialized constant Foo'
+            expect { ::Foo::Bar }.to raise_error NameError, 'uninitialized constant Foo'
+            expect { ::Foo::Bar::Baz }.to raise_error NameError, 'uninitialized constant Foo'
           end
-        }
+        end
+
+        context 'when some namespaces already exist' do
+          before { Imitate.mock 'FooModule::Bar::Baz' }
+          
+          it 'should remove the mocked object' do
+            Imitate.unmock_all
 
-        after { Object.instance_eval { remove_const 'Module1' } }
+            FooModule.should be
+            expect { ::FooModule::Bar }.to raise_error NameError, 'uninitialized constant FooModule::Bar'
+            expect { ::FooModule::Bar::Baz }.to raise_error NameError, 'uninitialized constant FooModule::Bar'
+          end
+        end
 
-        it 'should remove just class' do
-          Imitate.mock('Module1::Foo1')
-          Imitate.unmock('Module1::Foo1')
+        context 'when all namespaces already exist' do
+          before { Imitate.mock 'FooModule::BarModule::Bar' }
+          
+          it 'should remove the mocked object' do
+            Imitate.unmock_all
 
-          Module1.should be
-          lambda { Module1::Foo1 }.should raise_error
+            FooModule.should be
+            FooModule::BarModule.should be
+            expect { ::FooModule::BarModule::Bar }.to raise_error NameError, 'uninitialized constant FooModule::BarModule::Bar'
+          end
         end
       end
     end
+  end
 
-    context 'class doesnt exist' do
-      it 'should do nothing' do
-        Imitate.unmock('Foo1')
+  describe '.unmock_all' do
+    context 'without namespaces' do
+      before do
+        Imitate.mock 'Foo'
+        Imitate.mock 'Bar'
+      end
 
-        Imitate.expects(:remove_const).never
+      it 'should remove all mocked objects' do
+        Imitate.unmock_all
+
+        expect { ::Foo }.to raise_error NameError, 'uninitialized constant Foo'
+        expect { ::Bar }.to raise_error NameError, 'uninitialized constant Bar'
       end
     end
-  end
 
-  describe '.mock' do
-    context 'if const doesnt exist' do
-      context 'simple class' do
-        before { Imitate.mock('Foo') }
-        after { Imitate.unmock('Foo') }
+    context 'with namespaces' do
+      context 'when namespaces are not the same' do
+        before do
+          Imitate.mock 'Foo::Bar'
+          Imitate.mock 'Baz::Qux'
+        end
+        
+        it 'should remove all mocked objects' do
+          Imitate.unmock_all
 
-        it 'should create new dummy class' do
-          Foo.should be
-          Foo.class.should == Class
+          expect { ::Foo }.to raise_error NameError, 'uninitialized constant Foo'
+          expect { ::Foo::Bar }.to raise_error NameError, 'uninitialized constant Foo'
+
+          expect { ::Baz }.to raise_error NameError, 'uninitialized constant Baz'
+          expect { ::Baz::Qux }.to raise_error NameError, 'uninitialized constant Baz'
         end
       end
 
-      context 'class with block' do
-        before { 
-          Imitate.mock('Foo') do
-            def bar
-              'bar'
-            end
-          end
-        }
+      context 'when namespaces are the same' do
+        before do
+          Imitate.mock 'Foo::Bar'
+          Imitate.mock 'Foo::Baz'
+        end
+        
+        it 'should remove all mocked objects' do
+          Imitate.unmock_all
 
-        it 'should instance evaluate given block' do
-          Foo.new.methods.map(&:to_s).should include 'bar'
-          Foo.new.bar.should == 'bar'
+          expect { ::Foo }.to raise_error NameError, 'uninitialized constant Foo'
+          expect { ::Foo::Bar }.to raise_error NameError, 'uninitialized constant Foo'
+          expect { ::Foo::Baz }.to raise_error NameError, 'uninitialized constant Foo'
         end
       end
 
-      context 'class within namespace' do
-        before { Imitate.mock('Foo::Bar') }
+      context 'when namespaces already exist' do
+        before do
+          Imitate.mock 'FooModule::Foo'
+          Imitate.mock 'FooModule::Bar'
+        end
+        
+        it 'should remove all mocked objects' do
+          Imitate.unmock_all
 
-        it 'should create necessary namespace' do
-          Foo::Bar.should be
-          Foo::Bar.class.should == Class
+          FooModule.should be
+          expect { ::FooModule::Foo }.to raise_error NameError, 'uninitialized constant FooModule::Foo'
+          expect { ::FooModule::Bar }.to raise_error NameError, 'uninitialized constant FooModule::Bar'
         end
       end
     end
 
-    context 'if const exists' do
-      before { Imitate.mock('Imitate') }
+    context 'with deep namespaces' do
+      context 'when namespaces are not the same' do
+        before do
+          Imitate.mock 'Foo::Bar::Baz'
+          Imitate.mock 'Qux::Quux::Corge'
+        end
+        
+        it 'should remove all mocked objects' do
+          Imitate.unmock_all
+
+          expect { ::Foo }.to raise_error NameError, 'uninitialized constant Foo'
+          expect { ::Foo::Bar }.to raise_error NameError, 'uninitialized constant Foo'
+          expect { ::Foo::Bar::Baz }.to raise_error NameError, 'uninitialized constant Foo'
 
-      it 'should not override already existing object' do
-        Imitate.methods.map(&:to_s).should include 'mock'
+          expect { ::Qux }.to raise_error NameError, 'uninitialized constant Qux'
+          expect { ::Qux::Quux }.to raise_error NameError, 'uninitialized constant Qux'
+          expect { ::Qux::Quux::Corge }.to raise_error NameError, 'uninitialized constant Qux'
+        end
+      end
+
+      context 'when namespaces are the same' do
+        before do
+          Imitate.mock 'Foo::Bar::Baz'
+          Imitate.mock 'Foo::Bar::Qux'
+        end
+        
+        it 'should remove all mocked objects' do
+          Imitate.unmock_all
+
+          expect { ::Foo }.to raise_error NameError, 'uninitialized constant Foo'
+          expect { ::Foo::Bar }.to raise_error NameError, 'uninitialized constant Foo'
+          expect { ::Foo::Bar::Baz }.to raise_error NameError, 'uninitialized constant Foo'
+          expect { ::Foo::Bar::Qux }.to raise_error NameError, 'uninitialized constant Foo'
+        end
+      end
+
+      context 'when namespaces already exist' do
+        before do
+          Imitate.mock 'FooModule::Bar::Baz'
+          Imitate.mock 'FooModule::Bar::Qux'
+        end
+        
+        it 'should remove all mocked objects' do
+          Imitate.unmock_all
+
+          FooModule.should be
+          expect { ::FooModule::Bar }.to raise_error NameError, 'uninitialized constant FooModule::Bar'
+          expect { ::FooModule::Bar::Baz }.to raise_error NameError, 'uninitialized constant FooModule::Bar'
+          expect { ::FooModule::Bar::Qux }.to raise_error NameError, 'uninitialized constant FooModule::Bar'
+        end
+      end
+
+      context 'when all namespaces already exist' do
+        before do
+          Imitate.mock 'FooModule::BarModule::Bar'
+          Imitate.mock 'FooModule::BarModule::Baz'
+        end
+        
+        it 'should remove all mocked objects' do
+          Imitate.unmock_all
+
+          FooModule.should be
+          FooModule::BarModule.should be
+          expect { ::FooModule::BarModule::Bar }.to raise_error NameError, 'uninitialized constant FooModule::BarModule::Bar'
+          expect { ::FooModule::BarModule::Baz }.to raise_error NameError, 'uninitialized constant FooModule::BarModule::Baz'
+        end
       end
     end
   end

metadata

@@ -5,9 +5,9 @@ version: !ruby/object:Gem::Version
   prerelease: 
   segments: 
   - 0
-  - 1
-  - 6
-  version: 0.1.6
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Petr Janda