codders-dataset 1.3.2.1

data/lib/dataset/version.rb

@@ -0,0 +1,9 @@
+module Dataset
+  module VERSION #:nodoc:
+    MAJOR = 1
+    MINOR = 0
+    TINY  = 0
+    
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/plugit/descriptor.rb

@@ -0,0 +1,25 @@
+require 'rubygems'
+require 'plugit'
+
+PLUGIT_ROOT = File.expand_path(File.dirname(__FILE__))
+
+Plugit.describe do |dataset|
+  dataset.environments_root_path = "#{PLUGIT_ROOT}/environments"
+  vendor_directory               = "#{PLUGIT_ROOT}/../vendor/plugins"
+  
+  dataset.environment :default, 'Released versions of Rails and RSpec' do |env|
+    env.library :rails, :export => "git clone git://github.com/rails/rails.git" do |rails|
+      rails.after_update { `git fetch origin 2-3-stable:2-3-stable; git checkout 2-3-stable` }
+      rails.load_paths = %w{/activesupport/lib /activerecord/lib /actionpack/lib}
+      rails.requires = %w{active_support active_record active_record/fixtures action_controller action_view}
+    end
+    env.library :rspec, :export => "git clone git://github.com/dchelimsky/rspec.git" do |rspec|
+      rspec.after_update { `git checkout -b rspecrelease 1.1.12 && mkdir -p #{vendor_directory} && ln -nsf #{File.expand_path('.')} #{vendor_directory + '/rspec'}` }
+      rspec.requires = %w{spec}
+    end
+    env.library :cucumber, :export => "git clone git://github.com/aslakhellesoy/cucumber.git" do |cukes|
+      cukes.after_update { `git fetch origin master; git checkout v0.2.3.1` }
+      cukes.requires = %w{cucumber}
+    end
+  end
+end

data/spec/dataset/cucumber_spec.rb

@@ -0,0 +1,54 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+$:.unshift(File.dirname(__FILE__) + '/../stubs')
+require "mini_rails"
+
+require 'cucumber/rails/world'
+require 'cucumber/rails/rspec'
+Cucumber::Rails::World.class_eval do
+  include Dataset
+end
+
+describe Cucumber::Rails::World do
+  
+  it 'should have a dataset method' do
+    world = Class.new(Cucumber::Rails::World)
+    world.should respond_to(:dataset)
+  end
+  
+  it 'should load the dataset when the feature is run' do
+    load_count = 0
+    my_dataset = Class.new(Dataset::Base) do
+      define_method(:load) do
+        load_count += 1
+      end
+    end
+    
+    step_mother = Object.new
+    step_mother.extend(Cucumber::StepMother)
+    $__cucumber_toplevel = step_mother
+    step_mother.World do |world|
+      world = Cucumber::Rails::World.new
+      world.class.dataset(my_dataset)
+      world
+    end
+    step_mother.Given /true is true/ do |n|
+      true.should == true
+    end
+    visitor = Cucumber::Ast::Visitor.new(step_mother)
+    
+    scenario = Cucumber::Ast::Scenario.new(
+      background=nil,
+      comment=Cucumber::Ast::Comment.new(""),
+      tags=Cucumber::Ast::Tags.new(98, []), 
+      line=99,
+      keyword="",
+      name="", 
+      steps=[
+        Cucumber::Ast::Step.new(8, "Given", "true is true")
+      ])
+    visitor.visit_feature_element(scenario)
+    
+    load_count.should be(1)
+  end
+end

data/spec/dataset/database/base_spec.rb

@@ -0,0 +1,21 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Dataset::Database::Base do
+  before do
+    @database = Dataset::Database::Base.new
+  end
+  
+  it 'should clear the tables of all AR classes' do
+    Place.create!
+    Thing.create!
+    @database.clear
+    Place.count.should be(0)
+    Thing.count.should be(0)
+  end
+  
+  it 'should not clear the "schema_migrations" table' do
+    ActiveRecord::Base.connection.insert("INSERT INTO #{ActiveRecord::Migrator.schema_migrations_table_name} (version) VALUES ('testing123')")
+    @database.clear
+    ActiveRecord::Base.connection.select_one("SELECT version FROM #{ActiveRecord::Migrator.schema_migrations_table_name} WHERE version = 'testing123'").should_not be_blank
+  end
+end

data/spec/dataset/record/heirarchy_spec.rb

@@ -0,0 +1,14 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+class MThingy
+  class NThingy
+  end
+end
+
+describe Dataset::Record::Heirarchy, 'finder name' do
+  it 'should collapse single character followed by underscore to just the single character' do
+    @heirarchy = Dataset::Record::Heirarchy.new(Place)
+    @heirarchy.finder_name(MThingy).should == 'mthingy'
+    @heirarchy.finder_name(MThingy::NThingy).should == 'mthingy_nthingy'
+  end
+end

data/spec/dataset/resolver_spec.rb

@@ -0,0 +1,110 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+ResolveThis = Class.new(Dataset::Base)
+ResolveDataset = Class.new(Dataset::Base)
+SomeModelNotDs = Class.new
+SomeModelNotDsDataset = Class.new(Dataset::Base)
+NotADataset = Class.new
+TheModule = Module.new
+TheModuleDataset = Class.new(Dataset::Base)
+
+describe Dataset::Resolver do
+  before do
+    @resolver = Dataset::Resolver.new
+  end
+  
+  it 'should skip modules' do
+    @resolver.resolve(:the_module).should == TheModuleDataset
+  end
+  
+  it 'should find simply classified' do
+    @resolver.resolve(:resolve_this).should == ResolveThis
+  end
+  
+  it 'should find ending with Dataset' do
+    @resolver.resolve(:resolve).should == ResolveDataset
+  end
+  
+  it 'should keep looking if first try is not a dataset' do
+    dataset = @resolver.resolve(:some_model_not_ds)
+    dataset.should_not be(SomeModelNotDs)
+    dataset.should == SomeModelNotDsDataset
+  end
+  
+  it 'should indicate when found class is not a dataset' do
+    lambda do
+      @resolver.resolve(:not_a_dataset)
+    end.should raise_error(
+      Dataset::DatasetNotFound,
+      "Found a class 'NotADataset', but it does not subclass 'Dataset::Base'."
+    )
+  end
+  
+  it 'should indicate that it could not find a dataset' do
+    lambda do
+      @resolver.resolve(:undefined)
+    end.should raise_error(
+      Dataset::DatasetNotFound,
+      "Could not find a dataset 'Undefined' or 'UndefinedDataset'."
+    )
+  end
+end
+
+describe Dataset::DirectoryResolver do
+  before do
+    @resolver = Dataset::DirectoryResolver.new(SPEC_ROOT + '/fixtures/datasets')
+  end
+  
+  it 'should not look for a file if the constant is already defined' do
+    @resolver.resolve(:resolve).should be(ResolveDataset)
+  end
+  
+  it 'should find file with exact name match' do
+    defined?(ExactName).should be_nil
+    dataset = @resolver.resolve(:exact_name)
+    defined?(ExactName).should == 'constant'
+    dataset.should == ExactName
+  end
+  
+  it 'should find file with name ending in _dataset' do
+    defined?(EndingWithDataset).should be_nil
+    dataset = @resolver.resolve(:ending_with)
+    defined?(EndingWithDataset).should == 'constant'
+    dataset.should == EndingWithDataset
+  end
+  
+  it 'should indicate that it could not find a dataset file' do
+    lambda do
+      @resolver.resolve(:undefined)
+    end.should raise_error(
+      Dataset::DatasetNotFound,
+      %(Could not find a dataset file in ["#{SPEC_ROOT + '/fixtures/datasets'}"] having the name 'undefined.rb' or 'undefined_dataset.rb'.)
+    )
+  end
+  
+  it 'should indicate when it finds a file, but the constant is not defined after loading the file' do
+    lambda do
+      @resolver.resolve(:constant_not_defined)
+    end.should raise_error(
+      Dataset::DatasetNotFound,
+      "Found the dataset file '#{SPEC_ROOT + '/fixtures/datasets/constant_not_defined.rb'}', but it did not define a dataset 'ConstantNotDefined' or 'ConstantNotDefinedDataset'."
+    )
+  end
+  
+  it 'should indicate when it finds a file, but the constant defined is not a subclass of Dataset::Base' do
+    lambda do
+      @resolver.resolve(:not_a_dataset_base)
+    end.should raise_error(
+      Dataset::DatasetNotFound,
+      "Found the dataset file '#{SPEC_ROOT + '/fixtures/datasets/not_a_dataset_base.rb'}' and a class 'NotADatasetBase', but it does not subclass 'Dataset::Base'."
+    )
+  end
+  
+  it 'should support adding multiple directories' do
+    @resolver << (SPEC_ROOT + '/fixtures/more_datasets')
+    defined?(InAnotherDirectoryDataset).should be_nil
+    dataset = @resolver.resolve(:in_another_directory)
+    defined?(InAnotherDirectoryDataset).should == 'constant'
+    dataset.should == InAnotherDirectoryDataset
+  end
+end

data/spec/dataset/rspec_spec.rb

@@ -0,0 +1,133 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+class Spec::Example::ExampleGroup
+  include Dataset
+end
+
+describe Spec::Example::ExampleGroup do
+  with_sandboxed_options do
+    it 'should have a dataset method' do
+      group = Class.new(Spec::Example::ExampleGroup)
+      group.should respond_to(:dataset)
+    end
+    
+    it 'should load the dataset when the group is run' do
+      load_count = 0
+      dataset = Class.new(Dataset::Base) do
+        define_method(:load) do
+          load_count += 1
+        end
+      end
+      
+      group = Class.new(Spec::Example::ExampleGroup) do
+        self.dataset(dataset)
+        it('one') {}
+        it('two') {}
+      end
+      
+      group.run options
+      load_count.should be(1)
+    end
+    
+    it 'should load datasets in nested groups' do
+      dataset_one = Class.new(Dataset::Base) do
+        define_method(:load) do
+          Thing.create!
+        end
+      end
+      dataset_two = Class.new(Dataset::Base) do
+        define_method(:load) do
+          Place.create!
+        end
+      end
+      
+      group = Class.new(Spec::Example::ExampleGroup) do
+        dataset(dataset_one)
+        it('one') {}
+      end
+      group_child = Class.new(group) do
+        dataset(dataset_two)
+        it('two') {}
+      end
+      
+      group.run options
+      Thing.count.should be(1)
+      Place.count.should be(0)
+      
+      group_child.run options
+      Thing.count.should be(1)
+      Place.count.should be(1)
+    end
+    
+    it 'should expose data reading methods from dataset binding to the test methods through the group instances' do
+      created_model = nil
+      dataset = Class.new(Dataset::Base) do
+        define_method(:load) do
+          created_model = create_model(Thing, :dataset_thing)
+        end
+      end
+      
+      found_in_before_all, dataset_thing_in_example = nil
+      created_in_before_all, before_all_thing_in_example = nil
+      created_in_example = nil
+      group = Class.new(Spec::Example::ExampleGroup) do
+        self.dataset(dataset)
+        before(:all) do
+          found_in_before_all = things(:dataset_thing)
+          created_in_before_all = create_model(Thing, :before_all_thing)
+        end
+        it 'one' do
+          dataset_thing_in_example = things(:dataset_thing)
+          before_all_thing_in_example = things(:before_all_thing)
+          created_in_example = create_model(Thing)
+        end
+      end
+      
+      group.run options
+      group.should_not respond_to(:things)
+      
+      dataset_thing_in_example.should_not be_nil
+      dataset_thing_in_example.should == created_model
+      
+      found_in_before_all.should_not be_nil
+      found_in_before_all.should == created_model
+      
+      created_in_before_all.should_not be_nil
+      before_all_thing_in_example.should == created_in_before_all
+      
+      created_in_example.should_not be_nil
+    end
+    
+    it 'should expose dataset helper methods to the test methods through the group instances' do
+      dataset_one = Class.new(Dataset::Base) do
+        helpers do
+          def helper_one; end
+        end
+        def load; end
+      end
+      dataset_two = Class.new(Dataset::Base) do
+        uses dataset_one
+        helpers do
+          def helper_two; end
+        end
+        def load; end
+      end
+      
+      group = Class.new(Spec::Example::ExampleGroup) do
+        self.dataset(dataset_two)
+        before(:all) do
+          self.should respond_to(:helper_one)
+          self.should respond_to(:helper_two)
+        end
+        it 'one' do
+          self.should respond_to(:helper_one)
+          self.should respond_to(:helper_two)
+        end
+      end
+      
+      group.run options
+      group.should_not respond_to(:helper_one)
+      group.should_not respond_to(:helper_two)
+    end
+  end
+end

data/spec/dataset/session_binding_spec.rb

@@ -0,0 +1,203 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Dataset::SessionBinding do
+  before :all do
+    @database = Dataset::Database::Sqlite3.new({:database => SQLITE_DATABASE}, "#{SPEC_ROOT}/tmp")
+  end
+  
+  before do
+    @database.clear
+    @binding = Dataset::SessionBinding.new(@database)
+  end
+  
+  it 'should support direct record inserts like classic fixtures' do
+    Thing.should_not_receive :new
+    lambda do
+      return_value = @binding.create_record Thing
+      return_value.should be_kind_of(Integer)
+    end.should change(Thing, :count).by(1)
+  end
+  
+  it 'should support creating records by instantiating the record class so callbacks work' do
+    thing = Thing.new
+    Thing.should_receive(:new).and_return(thing)
+    lambda do
+      return_value = @binding.create_model Thing
+      return_value.should be_kind_of(Thing)
+    end.should change(Thing, :count).by(1)
+  end
+  
+  it 'should provide itself to the instance loaders' do
+    anything = Object.new
+    anything.extend @binding.model_finders
+    anything.dataset_session_binding.should == @binding
+  end
+  
+  describe 'create_record' do
+    it 'should accept raw attributes for the insert' do
+      @binding.create_record Thing, :name => 'my thing'
+      Thing.last.name.should == 'my thing'
+    end
+    
+    it 'should optionally accept a symbolic name for later lookup' do
+      id = @binding.create_record Thing, :my_thing, :name => 'my thing'
+      @binding.find_model(Thing, :my_thing).id.should == id
+      @binding.find_id(Thing, :my_thing).should == id
+    end
+    
+    it 'should auto-assign _at and _on columns with their respective time types' do
+      @binding.create_record Note
+      Note.last.created_at.should_not be_nil
+      Note.last.updated_at.should_not be_nil
+      
+      @binding.create_record Thing
+      Thing.last.created_on.should_not be_nil
+      Thing.last.updated_on.should_not be_nil
+    end
+    
+    it 'should support belongs_to associations using symbolic name of associated type' do
+      person_id = @binding.create_record Person, :person
+      @binding.create_record Note, :note, :person => :person
+      Note.last.person_id.should == person_id
+    end
+  end
+  
+  describe 'create_model' do
+    it 'should accept raw attributes for the insert' do
+      @binding.create_model Thing, :name => 'my thing'
+      Thing.last.name.should == 'my thing'
+    end
+    
+    it 'should optionally accept a symbolic name for later lookup' do
+      thing = @binding.create_model Thing, :my_thing, :name => 'my thing'
+      @binding.find_model(Thing, :my_thing).should == thing
+      @binding.find_id(Thing, :my_thing).should == thing.id
+    end
+    
+    it 'should bypass mass assignment restrictions' do
+      person = @binding.create_model Person, :first_name => 'Adam', :last_name => 'Williams'
+      person.last_name.should == 'Williams'
+    end
+    
+    
+    it 'should support belongs_to associations using symbolic name of associated type' do
+      person_id = @binding.create_record Person, :person
+      @binding.create_model Note, :note, :person => :person
+      Note.last.person_id.should == person_id
+    end
+  end
+  
+  describe 'model finders' do
+    before do
+      @context = Object.new
+      @context.extend @binding.model_finders
+      @note_one = @binding.create_model Note, :note_one
+    end
+    
+    it 'should not exist for types that have not been created' do
+      lambda do
+        @context.things(:whatever)
+      end.should raise_error(NoMethodError)
+    end
+    
+    it 'should exist for the base classes of created types' do
+      @binding.create_record State, :state_one
+      @context.places(:state_one).should_not be_nil
+      @context.places(:state_one).should == @context.states(:state_one)
+    end
+    
+    it 'should exist for all ancestors' do
+      @binding.create_record NorthCarolina, :nc
+      @context.states(:nc).should == @context.north_carolinas(:nc)
+    end
+    
+    it 'should exist for types made with create_model' do
+      @context.notes(:note_one).should == @note_one
+      @context.note_id(:note_one).should == @note_one.id
+    end
+    
+    it 'should exist for types made with create_record' do
+      id = @binding.create_record Note, :note_two
+      @context.notes(:note_two).id.should == id
+      @context.note_id(:note_two).should == id
+    end
+    
+    it 'should exist for types registered with name_model' do
+      thing = Thing.create!
+      @binding.name_model(thing, :thingy)
+      @context.things(:thingy).should == thing
+    end
+    
+    it 'should support multiple names, returning an array' do
+      note_two = @binding.create_model Note, :note_two
+      @context.notes(:note_one, :note_two).should == [@note_one, note_two]
+      @context.note_id(:note_one, :note_two).should == [@note_one.id, note_two.id]
+    end
+    
+    it 'should support models inside modules' do
+      @binding.create_record Nested::Place, :myplace, :name => 'Home'
+      @context.nested_places(:myplace).name.should == 'Home'
+    end
+  end
+  
+  describe 'name_model' do
+    before do
+      @place = Place.create!
+      @binding.name_model(@place, :myplace)
+      @state = State.create!(:name => 'NC')
+      @binding.name_model(@state, :mystate)
+    end
+    
+    it 'should allow assigning a name to a model for later lookup' do
+      @binding.find_model(Place, :myplace).should == @place
+      @binding.find_model(State, :mystate).should == @state
+    end
+    
+    it 'should allow finding STI' do
+      @context = Object.new
+      @context.extend @binding.model_finders
+      @context.places(:myplace).should == @place
+      @context.places(:mystate).should == @state
+      @context.states(:mystate).should == @state
+    end
+  end
+  
+  describe 'name_to_sym' do
+    it 'should convert strings to symbols' do
+      @binding.name_to_sym(nil).should == nil
+      @binding.name_to_sym('thing').should == :thing
+      @binding.name_to_sym('Mything').should == :mything
+      @binding.name_to_sym('MyThing').should == :my_thing
+      @binding.name_to_sym('My Thing').should == :my_thing
+      @binding.name_to_sym('"My Thing"').should == :my_thing
+      @binding.name_to_sym('\'My Thing\'').should == :my_thing
+    end
+  end
+  
+  describe 'nested bindings' do
+    before do
+      @binding.create_model Thing, :mything, :name => 'my thing'
+      @nested_binding = Dataset::SessionBinding.new(@binding)
+    end
+    
+    it 'should walk up the tree to find models' do
+      @nested_binding.find_model(Thing, :mything).should == @binding.find_model(Thing, :mything)
+    end
+    
+    it 'should raise an error if an object cannot be found for a name' do
+      lambda do
+        @nested_binding.find_model(Thing, :yourthing)
+      end.should raise_error(Dataset::RecordNotFound, "There is no 'Thing' found for the symbolic name ':yourthing'.")
+      
+      lambda do
+        @nested_binding.find_id(Thing, :yourthing)
+      end.should raise_error(Dataset::RecordNotFound, "There is no 'Thing' found for the symbolic name ':yourthing'.")
+    end
+    
+    it 'should have instance loader methods from parent binding' do
+      anything = Object.new
+      anything.extend @nested_binding.model_finders
+      anything.things(:mything).should_not be_nil
+    end
+  end
+end