fixie 0.1.0 → 0.2.0

data/README.md

@@ -1,6 +1,6 @@
 # Fixie
 
-A standalone library for managing test fixture data
+A standalone library for managing test fixture data with good support for multiple databases.
 
 ## Installation
 
@@ -22,31 +22,51 @@ To use Fixie, you first create some fixture files in a directory called `fixture
 
     test/
     └── fixtures
-        ├── cities.yml
-        └── countries.yml
+        └── default
+            ├── cities.yml
+            └── countries.yml
 
-Fixie use Sequel to load the data into the database.  Fixie will work even if you aren't using Sequel in your application.  You must configure the Fixie database and then include the Fixie module in your test class to use it.  Your test helper might look like this:
+You must put all your fixtures into a subdirectory of the `fixtures` directory.  The name of the directory should be a good logical name for the database that the fixtures.  If you have only one database, `default` is a reasonable name, but if you have an app with customers in one database and orders in another, you would name them `customers` and `orders`.
+
+Fixie uses Sequel to load the data into the database.  Fixie will work even if you aren't using Sequel in your application.  You must configure the Fixie databases and then call `load_fixtures` to get the fixtures to actually be loaded.  Your test helper might look like this:
 
 ``` ruby
-Fixie.db = Sequel.sqlite
+Fixie.dbs[:default] = Sequel.sqlite
+
+Fixie.load_fixtures
+```
+
+Now all the fixtures will be loaded into the test database.  In order to access them from a test, you need to mix the `Fixie::Model` module into the base class of your models.  For example, say you have models defined like this:
+
+``` ruby
+class Model
+end
 
-class Test::Unit::TestCase
-  include Fixie
+class Country < Model
 end
+
+class City < Model
+end
+```
+
+In your test helper, you mix in `Fixie::Model` like this:
+
+``` ruby
+Model.extend Fixie::Model
 ```
 
-Now all the fixtures will be loaded into the test database, and you can access them from within a test like this:
+Now in your tests, you can refer to fixtures like this:
 
 ``` ruby
 def test_something
-  assert_equal "US", countries(:us)
+  assert_equal "US", Country.fixture(:us)
 end
 ```
 
 You can also access the fixtures in any context once they have been loaded like this:
 
 ``` ruby
-Fixie.countries(:us)
+Fixie.fixture(:default, :countries, :us)
 ```
 
 Fixtures are defined in YAML files like this:
@@ -84,7 +104,7 @@ baltimore:
 The ERB is evaluated in the context of the Fixie module, so if there is anything else you want to make available in that context, just mix the module into Fixie:
 
 ``` ruby
-Fixie.extend(FastGettext::Translation)
+Fixie.extend FastGettext::Translation
 ```
 
 ``` yaml

data/fixie.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |gem|
   gem.name          = "fixie"
-  gem.version       = "0.1.0"
+  gem.version       = "0.2.0"
   gem.authors       = ["Paul Barry"]
   gem.email         = ["mail@paulbarry.com"]
   gem.description   = %q{A standalone library for managing test fixture data}

data/lib/fixie.rb

@@ -1,6 +1,7 @@
 require 'fixie/version'
 require 'active_support/core_ext'
 require 'erb'
+require 'sequel'
 require 'yaml'
 require 'zlib'
 
@@ -16,7 +17,11 @@ module Fixie
   end
 
   class << self
-    attr_accessor :db, :dir, :fixtures
+    attr_accessor :dbs, :dir, :fixtures
+  end
+
+  def self.dbs
+    @dbs ||= {}
   end
 
   def self.dir
@@ -28,60 +33,145 @@ module Fixie
     end
   end
 
-  def self.included(cls)
-    fixtures # load the fixtures
-  end
-
-  def self.fixtures
-    @fixtures ||= begin
-      all_fixtures = {}
-
+  def self.all_fixtures
+    @all_fixtures ||= begin
       unless Dir.exists?(Fixie.dir)
         raise "There is no directory in the $LOAD_PATH with a 'fixtures' directory in it"
       end
 
-      # First pass, load all the fixtures
-      Dir[File.join(Fixie.dir, "**/*.yml")].each do |file|
-        fixture_name = File.basename(file, '.yml')
-        fixture_class = fixture_name.singularize.classify.constantize
+      all_fixtures = {}
+
+      now = Time.now.utc
 
-        fixtures = YAML.load(ERB.new(IO.read(file)).result(binding)).symbolize_keys
+      dbs.each do |db_name, db|
+        all_fixtures[db_name] = {}
 
-        fixtures.each do |name, data|
-          data["id"] ||= identify(name)
-        end
+        # First pass, load all the fixtures
+        Dir[File.join(Fixie.dir, "#{db_name}/*.yml")].each do |file|
+          table_name = File.basename(file, '.yml')
 
-        unless respond_to?(fixture_name)
-          define_method(fixture_name) do |fixture|
-            fixture_class.new(fixtures[fixture])
+          fixtures = YAML.load(ERB.new(IO.read(file)).result(binding)).symbolize_keys
+
+          fixtures.each do |name, data|
+            data["id"] ||= identify(name)
           end
-        end
 
-        all_fixtures[fixture_name.to_sym] = fixtures
-      end
+          all_fixtures[db_name][table_name.to_sym] = fixtures
+        end
 
-      # Do a second pass to resolve associations
-      all_fixtures.each do |fixture_name, fixtures|
-        fixture_class = fixture_name.to_s.singularize.classify.constantize
-        fixtures.each do |name, data|
-          data.keys.each do |attr|
-            associated_fixtures = all_fixtures[attr.to_s.pluralize.to_sym]
-            if associated_fixtures && fixture_class.method_defined?("#{attr}_id=")
-              associated_fixture = associated_fixtures[data[attr].to_sym]
-              if associated_fixture
-                data["#{attr}_id"] = associated_fixture['id']
-                data.delete(attr)
+        # Do a second pass to resolve associations and load data in DB
+        all_fixtures[db_name].each do |table_name, fixtures|
+          table = db[table_name]
+          table_has_created_at = table.columns.include?(:created_at)
+          table_has_updated_at = table.columns.include?(:updated_at)
+
+          fixtures.each do |name, data|
+
+            # Change attributes like city: baltimore to city_id: baltimore.id
+            data.keys.each do |attr|
+              associated_fixtures = all_fixtures[db_name][attr.to_s.pluralize.to_sym]
+              if associated_fixtures && table.columns.include?("#{attr}_id".to_sym)
+                associated_fixture = associated_fixtures[data[attr].to_sym]
+                if associated_fixture
+                  data["#{attr}_id"] = associated_fixture['id']
+                  data.delete(attr)
+                end
               end
+
+              data["created_at"] = now if table_has_created_at && !data.key?("created_at")
+              data["updated_at"] = now if table_has_updated_at && !data.key?("updated_at")
             end
+
+            # Set created_at/updated_at if they exist
+
+            # Finally, put the data in the DB
+            table.insert(data)
           end
-          db[fixture_name].insert(data)
         end
-
       end
 
       all_fixtures
     end
   end
 
+  def self.fixture(db_name, table_name, fixture_name)
+    db = all_fixtures[db_name]
+    if db
+      fixtures = db[table_name]
+      if fixtures
+        fixture = fixtures[fixture_name]
+        if fixture
+          fixture
+        else
+          raise "No fixture #{fixture_name.inspect} in #{db_name}.#{table_name}"
+        end
+      else
+        raise "No fixtures for #{table_name.inspect} in #{db_name.inspect}"
+      end
+    else
+      raise "Unknown fixture database #{db_name.inspect}"
+    end
+  end
+
+  def self.load_fixtures
+    Fixie.all_fixtures
+  end
+
+  module Model
+    # This will return an instance of this class loaded from
+    # the fixtures matching the name
+    #
+    # @param fixture_name [Symbol] The name of the fixture
+    # @return [Object] An instance of this class
+    def fixture(fixture_name)
+      @fixtures ||= {}
+      fixture = @fixtures[fixture_name]
+      if fixture
+        fixture
+      else
+        @fixtures[fixture_name] = instantiate_from_fixture(Fixie.fixture(fixture_db_name, fixture_table_name, fixture_name))
+      end
+    end
+
+    # This method is used to get an instance of the model from a fixture hash.
+    # The default implementation is to just pass the hash to the model's constructor.
+    #
+    # @param fixture [Hash<String, Object>] The fixture
+    # @return [Object] An instance of this class
+    def instantiate_from_fixture(fixture)
+      new(fixture)
+    end
+
+    # This method determine which database is used to load the fixture.
+    # The default implementation is to check the class to see if it has a
+    # namespace, like 'Foo::Bar', and if it does, return :foo.
+    # If it does not have a namespace, it will return :default.
+    #
+    # You should override this method if you have multiple databases in your app
+    # and you have a different way of determining the DB name based on the class.
+    #
+    # @return [Symbol] The db name for this class
+    def fixture_db_name
+      if match_data = name.match(/([^:]+)::/)
+        match_data[1].to_sym
+      else
+        :default
+      end
+    end
+
+    # This method returns the name of the table that the fixtures for this model
+    # should be loaded into/from.  The default is to just underscore and pluralize
+    # the table name, e.g. City => cities.
+    #
+    # @return [Symbol] The table name for this class
+    def fixture_table_name
+      @fixture_table_name ||= if respond_to?(:table_name)
+        table_name.to_sym
+      else
+        name.demodulize.tableize.to_sym
+      end
+    end
+  end
+
   extend self
 end

data/lib/fixie/version.rb

@@ -1,3 +1,3 @@
 module Fixie
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/test/fixie_test.rb

@@ -26,15 +26,15 @@ class City < Model
   attr_accessor :name, :country, :country_id, :created_at
 end
 
-Fixie.db = Sequel.sqlite(logger: Logger.new("log/test.log"))
+db = Sequel.sqlite(logger: Logger.new("log/test.log"))
 
-Fixie.db.create_table :countries do
+db.create_table :countries do
   primary_key :id
   String :name
   String :code
 end
 
-Fixie.db.create_table :cities do
+db.create_table :cities do
   primary_key :id
   Integer :country_id
   String :name
@@ -42,46 +42,53 @@ Fixie.db.create_table :cities do
   Time :created_at
 end
 
+Fixie.dbs[:default] = db
+
 module FakeGetText
   def _(key)
     key.to_s.titleize
   end
 end
 
-Fixie.extend(FakeGetText)
+Fixie.extend FakeGetText
+Fixie.load_fixtures
+Model.extend Fixie::Model
 
 class FixieTest < MiniTest::Unit::TestCase
-  include Fixie
 
   def test_explicit_id
-    assert_equal "United States", countries(:us).name
-    assert_equal 1, countries(:us).id
+    assert_equal "United States", Country.fixture(:us).name
+    assert_equal 1, Country.fixture(:us).id
   end
 
   def test_implicity_id
-    assert_equal "Canada", countries(:canada).name
-    assert_equal 842554592, countries(:canada).id
+    assert_equal "Canada", Country.fixture(:canada).name
+    assert_equal 842554592, Country.fixture(:canada).id
   end
 
   def test_association
-    assert_equal countries(:us).id, cities(:baltimore).country_id
+    assert_equal Country.fixture(:us).id, City.fixture(:baltimore).country_id
     # TODO: make this work
-    # assert_equal countries(:us), cities(:baltimore).country
+    # assert_equal countries(:us), City.fixture(:baltimore).country
   end
 
   def test_get
-    assert_equal "US", Fixie.countries(:us).code
+    assert_equal "US", Fixie.fixture(:default, :countries, :us)["code"]
   end
 
   def test_loaded_in_db
-    assert_equal ["CA","US"], Fixie.db[:countries].all.map{|c| c[:code] }.sort
+    assert_equal ["CA","US"], Fixie.dbs[:default][:countries].all.map{|c| c[:code] }.sort
   end
 
   def test_erb
-    assert_equal Time, cities(:baltimore).created_at.class
+    assert_equal Time, City.fixture(:baltimore).created_at.class
   end
 
   def test_erb_is_evaled_in_context_of_fixie
-    assert_equal "Baltimore", cities(:baltimore).name
+    assert_equal "Baltimore", City.fixture(:baltimore).name
+  end
+
+  def test_timestamps
+    assert City.fixture(:baltimore).created_at.present?
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fixie
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-12 00:00:00.000000000 Z
+date: 2013-05-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -75,8 +75,8 @@ files:
 - lib/fixie.rb
 - lib/fixie/version.rb
 - test/fixie_test.rb
-- test/fixtures/cities.yml
-- test/fixtures/countries.yml
+- test/fixtures/default/cities.yml
+- test/fixtures/default/countries.yml
 homepage: http://github.com/pjb3/fixie
 licenses: []
 post_install_message: 
@@ -103,6 +103,6 @@ specification_version: 3
 summary: A standalone library for managing test fixture data
 test_files:
 - test/fixie_test.rb
-- test/fixtures/cities.yml
-- test/fixtures/countries.yml
+- test/fixtures/default/cities.yml
+- test/fixtures/default/countries.yml
 has_rdoc: