application_seeds 0.0.1

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.ruby-version
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in application_seeds.gemspec
+gemspec

data/README.md

@@ -0,0 +1,319 @@
+# application_seeds
+
+A library for managing a standardized set of seed data for applications
+in a non-production environment.
+
+
+## Requirements
+
+* Postgresql - This library currently only works with the Postgresql
+database.
+
+
+## Usage
+
+#### Include the gem in your Gemfile
+
+    group :development, :test, :integration, :staging do
+      gem 'application_seeds', :git => 'git@github.com:centro/application_seeds.git'
+    end
+
+
+#### Create a rake task to create data model objects from the seed data
+
+**The application** needs to create objects from the common seed data.  To
+do this, the application will need to create Rake task (such as the one
+below) that reads the seed data, and uses it to create the objects in
+the application's own data model.
+
+`ApplicationSeeds` provides an API to allow for the easy retrieveal of
+seed data.  See blow for more information about the API.
+
+```ruby
+namespace :application_seeds do
+  desc 'Dump the development database and load it with standardized application seed data'
+  task :load, [:dataset] => ['db:drop', 'db:create', 'db:migrate', :environment] do |t, args|
+    ApplicationSeeds.dataset = args[:dataset]
+
+    seed_campaigns
+    seed_line_items
+    seed_some_other_objects
+  end
+
+  def seed_campaigns
+    # If we do not need to change the attirbute hash, we can just create
+    # the object with the attributes that are specified in the seed data
+    # file.
+    ApplicationSeeds.campaigns.each do |id, attributes|
+      ApplicationSeeds.create_object!(Campaign, id, attributes)
+    end
+  end
+
+  def seed_line_items
+    # If we need to reject attributes from the attribute hash, or
+    # only use specific attributes, we can use the select_attributes or
+    # the reject_attributes helper methods.
+    ApplicationSeeds.line_items.each do |id, attributes|
+      ApplicationSeeds.create_object!(LineItem, id, attributes.reject_attributes(:some_unused_attribute))
+    end
+  end
+
+  def seed_some_objects
+    # If we need to modify attribute names, we can do so using the
+    # map_attributes helper method.
+    ApplicationSeeds.some_objects.each do |id, attributes|
+      ApplicationSeeds.create_object!(SomeObject, id, attributes.map_attributes(
+        :old_name1 => :new_name1, :old_name2 => :new_name2))
+    end
+  end
+
+  def seed_some_other_objects
+    # If we need tighter control over how the object is created, we can
+    # simply create it ourselves.
+    ApplicationSeeds.some_other_objects.each do |id, attributes|
+      x = SomeOtherObject.new(param1: attributes['param1'],
+                              param2: attributes['param2'],
+                              param3: attributes['param3'])
+      x.id = id
+      x.save!
+    end
+  end
+end
+```
+
+#### Run the rake task
+
+    bundle exec rake application_seeds:load[your_data_set]
+
+You must specify the seed data set that you would like to use.  The dataset name is
+simply the name of the directory containing the seed YAML files.
+
+
+#### Or, run the capistrano task
+
+Add the following line to your deploy.rb file:
+
+    require "application_seeds/capistrano"
+
+Then, you can seed a remote database by running the following:
+
+    bundle exec cap <environment> deploy:application_seeds -s dataset=your_data_set
+
+
+## The API
+
+The `ApplicationSeeds` module provides an API that enables the programmatic retrieval of seed data,
+so the rake task can easily access all the seed data necessary to build the data object.
+
+
+### Specify the name of the directory containing the seed data
+
+```ruby
+ApplicationSeeds.data_directory = "/path/to/seeds/directory"
+```
+
+Specify the name of the directory that contains the application seed data.
+
+
+### Specify the name of the gem containing the seed data
+
+```ruby
+ApplicationSeeds.data_gem_name = "my-seed-data-gem"
+```
+
+Specify the name of the gem that contains the application seed data.
+Defaults to `application_seed_data` if this method is not called.
+
+
+### Specify the dataset to be loaded
+
+```ruby
+ApplicationSeeds.dataset = "name_of_your_dataset"
+```
+
+Specify the name of the dataset to use.  An exception will be raised if
+the dataset could not be found.
+
+
+### Determining the dataset that has been loaded
+
+```ruby
+ApplicationSeeds.dataset
+```
+
+Returns the name of the dataset that has been loaded, or nil if not
+running an application_seeds dataset.
+
+
+### Checking if a seed file exists in the dataset
+
+```ruby
+ApplicationSeeds.seed_data_exists?(:campaigns)
+```
+
+Returns `true` if `campaigns.yml` exists in this dataset, `false` if it
+does not.
+
+
+### Fetching all seeds of a given type
+
+```ruby
+ApplicationSeeds.campaigns  # where "campaigns" is the name of the seed file
+```
+    
+This call returns a hash with one or more entries (depending on the contentes of the seed file).
+The IDs of the object are the keys, and a hash containing the object's attributes are the values.
+An exception is raised if no seed data could be with the given name.
+
+
+### Fetching seed data by ID
+
+```ruby
+ApplicationSeeds.campaigns(1)  # where "campaigns" is the name of the seed file, and 1 is the ID of the campaign
+```
+
+This call returns a hash containing the object's attributes.  An exception is raised if no
+seed data could be found with the given ID.
+
+
+### Fetching seed data by some other attribute
+
+```ruby
+ApplicationSeeds.campaigns(foo: 'bar', name: 'John')  # where "campaigns" is the name of the seed file
+```
+
+This call returns the seed data that contains the specified attributes,
+and the specified attribute values.  It returns a hash with zero or more
+entries.  The IDs of the object are the keys of the hash, and a hash
+containing the object's attributes are the values.  Any empty hash will
+be returned if no seed data could be found with the given attribute names
+and values.
+
+
+### Creating an object
+
+```ruby
+ApplicationSeeds.create_object!(Campaign, id, attributes)
+```
+
+This call will create a new instance of the `Campaign` class, with the
+specified id and attributes.
+
+
+### Rejecting specific attributes
+
+```ruby
+ApplicationSeeds.create_object!(Campaign, id, attributes.reject_attributes(:unused_attribute))
+```
+
+This call will create a new instance of the `Campaign` class without the
+`unused_attribute` attribute.
+
+
+### Selecting specific attributes
+
+```ruby
+ApplicationSeeds.create_object!(Campaign, id, attributes.select_attributes(:attribute1, :attribute2))
+```
+
+This call will create a new instance of the `Campaign` class with only the
+`attribute1` and `attribute2` attributes.
+
+
+### Mapping attribute names
+
+```ruby
+ApplicationSeeds.create_object!(Campaign, id, attributes.map_attributes(
+  :old_name1 => :new_name1, :old_name2 => :new_name2))
+```
+
+This call will create a new instance of the `Campaign` class, using the
+seed data for old_name1 as the attribute value for new_name1, and the
+seed data for old_name2 as the attribute value for new_name2.  This
+method let's you easly account for slight differences is attribute names
+across applications.
+
+
+### Reset id column sequence numbers
+
+```ruby
+ApplicationSeeds.reset_sequence_numbers
+```
+
+This method will reset the sequence numbers on id columns for all tables
+in the database with an id column.  If you are having issues where you
+are unable to insert new data into the databse after your dataset has
+been imported, then this should correct them.
+
+
+## The Problem
+
+Applications in a service oriented architecture (SOA) are often
+interconnected.  One of the challenges with a SOA is that, since the
+applications are (and must be to some extent) all interconnected, the
+data sets used by the different applications must be *in sync*.
+
+Applications will need to store keys to data in other applications that
+can be used to fetch more detailed information from the services that
+own that data.  In order for one application to lookup data owned by
+another application, the key specified by the client must be in the server's
+data set, along with the other data associated with the key that the
+client is requesting.
+
+Often, each application will have its own, sioled seed data, making
+inter-app communication impossible.  In order to get all of the
+application data in sync, developers will often resort to populating
+their development databases with production data.  Production data on a
+developer machine (*especially* a laptop) is bad business.  Do you want
+to send the email to all of your customers telling them that their
+sensitive data was on a stolen laptop?  I didn't think so.
+
+
+## The Goal
+
+The goal of this project is to create a common set of seed data that can
+be used by all applications running in development.  Re-seeding
+the applications in development with this shared seed data would put them
+all "on the same page", preparing them for inter-app communication.
+
+The seed data would be in a general format, not formatted to any
+application's data model.  Each application will have a script that
+mutates this seed data to confirm to its data model, and then persist it
+to its database.
+
+
+## FAQ
+
+#### Why not just stub calls to the respective services?
+
+Easier said than done :)  Yes, it would be fantastic if we could run an
+application in isolation, and everything just works.  But maintaining
+the stubs can be difficult.  Also, when you stub out service calls,
+you're not really testing the inter-app communication process.  More importantly,
+stubbing out the calls really only works for read-only APIs.  For APIs that
+create or mutate data, stubbing isn't an ideal strategy.  What happens
+when the app tries to fetch data that it just created/updated on a remote
+service?  How will you see the data you created/updated?
+
+
+#### Doesn't this mean that I need all applications running, all of the time?
+
+Not really.  But, you will need to be running the applications that
+service API calls for whatever it is that you are developing/testing.
+This is where [POW](http://pow.cx/) comes in.  POW is a zero-config Rack
+server for OSX.  After installing POW, your apps will be accessible via a
+.dev url, like http://myapp.dev  No more remembering to
+start an application before you use one of its services.  No more
+remembering which applications run on which ports.  If your application
+is not currently running, POW will start it automatically on the fly.
+
+
+#### Sounds great, what's the catch?
+
+Making it easier for our applications to talk to one another does have
+some disadvantages.  One being that it makes it easier to
+couple applications.  The goal of a service oriented
+architecture is to prevent this.  With great power comes great
+responsibility.  Carefully consider the trade offs any time you
+introduce an API call to fetch data from a remote service.
+

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/application_seeds.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'application_seeds/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "application_seeds"
+  gem.version       = ApplicationSeeds::VERSION
+  gem.authors       = ["John Wood"]
+  gem.email         = ["john.wood@centro.net"]
+  gem.description   = %q{A library for managing standardized application seed data}
+  gem.summary       = %q{A library for managing a standardized set of seed data for applications in a non-production environment}
+  gem.homepage      = "https://github.com/centro/application_seeds"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency "activesupport"
+  gem.add_dependency "pg"
+
+  gem.add_development_dependency "rspec"
+  gem.add_development_dependency "rake"
+end

data/lib/application_seeds/attributes.rb

@@ -0,0 +1,35 @@
+require 'delegate'
+
+module ApplicationSeeds
+  class Attributes < DelegateClass(Hash)
+
+    def initialize(attributes)
+      super(attributes)
+    end
+
+    def select_attributes(*attribute_names)
+      attribute_names.map!(&:to_s)
+      select { |k,v| attribute_names.include?(k) }
+    end
+
+    def reject_attributes(*attribute_names)
+      attribute_names.map!(&:to_s)
+      reject { |k,v| attribute_names.include?(k) }
+    end
+
+    def map_attributes(mapping)
+      mapping.stringify_keys!
+
+      mapped = {}
+      each do |k,v|
+        if mapping.keys.include?(k)
+          mapped[mapping[k].to_s] = v
+        else
+          mapped[k] = v
+        end
+      end
+      Attributes.new(mapped)
+    end
+
+  end
+end

data/lib/application_seeds/capistrano.rb

@@ -0,0 +1,30 @@
+require 'capistrano'
+
+module ApplicationSeeds
+  module Capistrano
+
+    def self.load_into(configuration)
+      configuration.load do
+        set :dataset, ""
+
+        namespace :deploy do
+          task :application_seeds do
+            raise "You cannot run this task in the production environment" if rails_env == "production"
+
+            if dataset == ""
+              run %Q{cd #{latest_release} && #{rake} RAILS_ENV=#{rails_env} db:seed}
+            else
+              run %Q{cd #{latest_release} && #{rake} RAILS_ENV=#{rails_env} application_seeds:load\[#{dataset}\]}
+            end
+          end
+        end
+      end
+    end
+
+  end
+end
+
+if Capistrano::Configuration.instance
+  ApplicationSeeds::Capistrano.load_into(Capistrano::Configuration.instance)
+end
+

data/lib/application_seeds/database.rb

@@ -0,0 +1,27 @@
+module ApplicationSeeds
+  class Database
+
+    class << self
+      def connection
+        return @connection unless @connection.nil?
+
+        database_config = YAML.load(ERB.new(File.read("config/database.yml")).result)[Rails.env]
+
+        pg_config = {}
+        pg_config[:dbname]   = database_config['database']
+        pg_config[:host]     = database_config['host']     if database_config['host']
+        pg_config[:port]     = database_config['port']     if database_config['port']
+        pg_config[:user]     = database_config['username'] if database_config['username']
+        pg_config[:password] = database_config['password'] if database_config['password']
+
+        @connection = PG.connect(pg_config)
+      end
+
+      def create_metadata_table
+        connection.exec('DROP TABLE IF EXISTS application_seeds;')
+        connection.exec('CREATE TABLE application_seeds (dataset varchar(255));')
+      end
+    end
+
+  end
+end

data/lib/application_seeds/version.rb

@@ -0,0 +1,3 @@
+module ApplicationSeeds
+  VERSION = "0.0.1"
+end

data/lib/application_seeds.rb

@@ -0,0 +1,255 @@
+require "yaml"
+require "erb"
+require "pg"
+require "active_support"
+require "active_support/core_ext"
+
+require "application_seeds/database"
+require "application_seeds/version"
+require "application_seeds/attributes"
+
+# A library for managing a standardized set of seed data for applications in a non-production environment.
+#
+# == The API
+#
+# === Fetching all seeds of a given type
+#
+#   ApplicationSeeds.campaigns  # where "campaigns" is the name of the seed file
+#
+# This call returns a hash with one or more entries (depending on the contentes of the seed file).
+# The IDs of the object are the keys, and a hash containing the object's attributes are the values.
+# An exception is raised if no seed data could be with the given name.
+#
+# === Fetching seed data by ID
+#
+#   ApplicationSeeds.campaigns(1)  # where "campaigns" is the name of the seed file, and 1 is the ID of the campaign
+#
+# This call returns a hash containing the object's attributes.  An exception is raised if no
+# seed data could be found with the given ID.
+#
+# === Fetching seed data by some other attribute
+#
+#   ApplicationSeeds.campaigns(foo: 'bar', name: 'John')  # where "campaigns" is the name of the seed file
+#
+# This call returns the seed data that contains the specified attributes,
+# and the specified attribute values.  It returns a hash with zero or more
+# entries.  The IDs of the object are the keys of the hash, and a hash
+# containing the object's attributes are the values.  Any empty hash will
+# be returned if no seed data could be found with the given attribute names
+# and values.
+#
+# === Creating an object
+#
+#   ApplicationSeeds.create_object!(Campaign, id, attributes)
+#
+# This call will create a new instance of the <tt>Campaign</tt> class, with the
+# specified id and attributes.
+#
+# === Rejecting specific attributes
+#
+#   ApplicationSeeds.create_object!(Campaign, id, attributes.reject_attributes(:unused_attribute))
+#
+# This call will create a new instance of the <tt>Campaign</tt> class without the
+# <tt>unused_attribute</tt> attribute.
+#
+# === Selecting specific attributes
+#
+#   ApplicationSeeds.create_object!(Campaign, id, attributes.select_attributes(:attribute1, :attribute2))
+#
+# This call will create a new instance of the <tt>Campaign</tt> class with only the
+# <tt>attribute1</tt> and <tt>attribute2</tt> attributes.
+#
+# === Mapping attribute names
+#
+#   ApplicationSeeds.create_object!(Campaign, id, attributes.map_attributes(
+#     :old_name1 => :new_name1, :old_name2 => :new_name2))
+#
+# This call will create a new instance of the <tt>Campaign</tt> class, using the
+# seed data for old_name1 as the attribute value for new_name1, and the
+# seed data for old_name2 as the attribute value for new_name2.  This
+# method let's you easly account for slight differences is attribute names
+# across applications.
+#
+module ApplicationSeeds
+  class << self
+
+    #
+    # Specify the name of the gem that contains the application seed data.
+    #
+    def data_gem_name=(gem_name)
+      spec = Gem::Specification.find_by_name(gem_name)
+      if Dir.exist?(File.join(spec.gem_dir, "lib", "seeds"))
+        @data_gem_name = gem_name
+      else
+        raise "ERROR: The #{gem_name} gem does not appear to contain application seed data"
+      end
+    end
+
+    #
+    # Fetch the name of the directory where the application seed data is loaded from.
+    # Defaults to <tt>"applicadtion_seed_data"</tt> if it was not set using <tt>data_gem_name=</tt>.
+    #
+    def data_gem_name
+      @data_gem_name || "application_seed_data"
+    end
+
+    #
+    # Specify the name of the directory that contains the application seed data.
+    #
+    def data_directory=(directory)
+      if Dir.exist?(directory)
+        @data_directory = directory
+      else
+        raise "ERROR: The #{directory} directory does not appear to contain application seed data"
+      end
+    end
+
+    #
+    # Fetch the name of the directory where the application seed data is loaded from,
+    # if it was set using <tt>data_diretory=</tt>.
+    #
+    def data_directory
+      @data_directory
+    end
+
+    #
+    # Specify the name of the dataset to use.  An exception will be raised if
+    # the dataset could not be found.
+    #
+    def dataset=(dataset)
+      if dataset.nil? || dataset.strip.empty? || !Dir.exist?(File.join(seed_data_path, dataset))
+        datasets = Dir[File.join(seed_data_path, "*")].map { |x| File.basename(x) }.join(', ')
+
+        error_message =  "\nERROR: A valid dataset is required!\n"
+        error_message << "Usage: bundle exec rake application_seeds:load[your_data_set]\n\n"
+        error_message << "Available datasets: #{datasets}\n\n"
+        raise error_message
+      end
+
+      Database.create_metadata_table
+      Database.connection.exec("INSERT INTO application_seeds (dataset) VALUES ('#{dataset}');")
+
+      @dataset = dataset
+    end
+
+    #
+    # Returns the name of the dataset that has been loaded, or nil if not
+    # running an application_seeds dataset.
+    #
+    def dataset
+      res = Database.connection.exec("SELECT dataset from application_seeds LIMIT 1;")
+      res.getvalue(0, 0)
+    rescue PG::Error => e
+      e.message =~ /relation "application_seeds" does not exist/ ? nil : raise
+    end
+
+    #
+    # This call will create a new instance of the specified class, with the
+    # specified id and attributes.
+    #
+    def create_object!(clazz, id, attributes, options={})
+      validate = options[:validate].nil? ? true : options[:validate]
+
+      x = clazz.new
+      x.attributes = attributes.reject { |k,v| !x.respond_to?("#{k}=") }
+      x.id = id
+      x.save!(:validate => validate)
+      x
+    end
+
+    #
+    # Returns <tt>true</tt> if the specified data file exists in this dataset, <tt>false</tt> if it
+    # does not.
+    #
+    # Examples:
+    #   ApplicationSeeds.seed_data_exists?(:campaigns)
+    #
+    def seed_data_exists?(type)
+      File.exist?(File.join(seed_data_path, @dataset, "#{type}.yml"))
+    end
+
+    #
+    # This method will reset the sequence numbers on id columns for all tables
+    # in the database with an id column.  If you are having issues where you
+    # are unable to insert new data into the databse after your dataset has
+    # been imported, then this should correct them.
+    #
+    def reset_sequence_numbers
+      result = Database.connection.exec("SELECT table_name FROM information_schema.tables WHERE table_schema = 'public';")
+      table_names = result.map { |row| row.values_at('table_name')[0] }
+
+      table_names_with_id_column = table_names.select do |table_name|
+        result = Database.connection.exec("SELECT column_name FROM information_schema.columns WHERE table_name = '#{table_name}';")
+        column_names = result.map { |row| row.values_at('column_name')[0] }
+        column_names.include?('id')
+      end
+
+      table_names_with_id_column.each do |table_name|
+        result = Database.connection.exec("SELECT pg_get_serial_sequence('#{table_name}', 'id');")
+        sequence_name = result.getvalue(0, 0)
+        Database.connection.exec("SELECT setval('#{sequence_name}', (select MAX(id) from #{table_name}));")
+      end
+    end
+
+    private
+
+    def method_missing(method, *args)
+      self.send(:seed_data, method, args.shift)
+    end
+
+    def seed_data(type, options)
+      @seed_data ||= {}
+      @seed_data[type] ||= load_seed_data(type)
+      raise "No seed data could be found for '#{type}'" if @seed_data[type].nil?
+
+      if options.nil?
+        fetch(type)
+      elsif options.is_a?(Fixnum) || options.is_a?(String)
+        fetch_with_id(type, options)
+      elsif options.is_a? Hash
+        fetch(type) do |attributes|
+          (options.stringify_keys.to_a - attributes.to_a).empty?
+        end
+      end
+    end
+
+    def load_seed_data(type)
+      data_file = File.join(seed_data_path, @dataset, "#{type}.yml")
+      if File.exist?(data_file)
+        YAML.load(ERB.new(File.read(data_file)).result)
+      else
+        nil
+      end
+    end
+
+    def seed_data_path
+      return @seed_data_path unless @seed_data_path.nil?
+
+      if data_directory
+        @seed_data_path = data_directory
+      else
+        spec = Gem::Specification.find_by_name(data_gem_name)
+        @seed_data_path = File.join(spec.gem_dir, "lib", "seeds")
+      end
+    end
+
+    def fetch(type, &block)
+      result = {}
+      @seed_data[type].each do |d|
+        attributes = d.clone
+        id = attributes.delete('id')
+        if !block_given? || (block_given? && yield(attributes) == true)
+          result[id] = Attributes.new(attributes)
+        end
+      end
+      result
+    end
+
+    def fetch_with_id(type, id)
+      data = @seed_data[type].find { |d| d['id'].to_s == id.to_s }
+      raise "No seed data could be found for '#{type}' with id #{id}" if data.nil?
+      Attributes.new(data)
+    end
+
+  end
+end

data/spec/application_seeds_spec.rb

@@ -0,0 +1,83 @@
+require 'application_seeds'
+
+describe "ApplicationSeeds" do
+  before do
+    ApplicationSeeds.data_directory = File.join(File.dirname(__FILE__), "seed_data")
+  end
+
+  describe "#data_gem_name=" do
+    it "raises an error if no gem could be found with the specified name" do
+      expect { ApplicationSeeds.data_gem_name = "foo" }.to raise_error(Gem::LoadError)
+    end
+    it "raises an error if the specified gem does not contain seed data" do
+      expect { ApplicationSeeds.data_gem_name = "rspec" }.to raise_error(RuntimeError, /does not appear to contain application seed data/)
+    end
+  end
+
+  describe "#data_gem_name" do
+    it "defaults to 'application_seed_data'" do
+      ApplicationSeeds.data_gem_name.should == "application_seed_data"
+    end
+  end
+
+  describe "#data_directory" do
+    it "is able to set the data directory successfully" do
+      ApplicationSeeds.data_directory.should == File.join(File.dirname(__FILE__), "seed_data")
+    end
+    it "raises an error if a non-existant directory specified" do
+      expect { ApplicationSeeds.data_directory = "/foo/bar" }.to raise_error
+    end
+  end
+
+  describe "#dataset=" do
+    context "when an invalid dataset is specified" do
+      it "raises an error if a nil dataset is specified" do
+        expect { ApplicationSeeds.dataset = nil }.to raise_error
+      end
+      it "raises an error if a blank dataset is specified" do
+        expect { ApplicationSeeds.dataset = "  " }.to raise_error
+      end
+      it "raises an error if an unknown dataset is specified" do
+        expect { ApplicationSeeds.dataset = "foo" }.to raise_error
+      end
+      it "lists the available datasets in the error message" do
+        expect { ApplicationSeeds.dataset = nil }.to raise_error(RuntimeError, /Available datasets: test_data_set/)
+      end
+    end
+
+    context "when a valid dataset is specified" do
+      before do
+        connection_dummy = double
+        connection_dummy.should_receive(:exec).with("INSERT INTO application_seeds (dataset) VALUES ('test_data_set');")
+        ApplicationSeeds::Database.should_receive(:create_metadata_table)
+        ApplicationSeeds::Database.should_receive(:connection) { connection_dummy }
+        ApplicationSeeds.dataset = "test_data_set"
+      end
+      it "sets the dataset" do
+        ApplicationSeeds.instance_variable_get(:@dataset).should == "test_data_set"
+      end
+    end
+  end
+
+  describe "#dataset" do
+    before do
+      connection_dummy = double
+      response_dummy = double(:getvalue => "test_data_set")
+      connection_dummy.should_receive(:exec).with("SELECT dataset from application_seeds LIMIT 1;") { response_dummy }
+      ApplicationSeeds::Database.should_receive(:connection) { connection_dummy }
+    end
+    it "fetches the dataset name from the database" do
+      ApplicationSeeds.dataset.should == "test_data_set"
+    end
+  end
+
+  describe "#seed_data_exists?" do
+    it "returns true if the specified seed data exists" do
+      ApplicationSeeds.seed_data_exists?(:people).should be_true
+    end
+    it "returns false if the specified seed data does not exist" do
+      ApplicationSeeds.seed_data_exists?(:missing).should_not be_true
+    end
+  end
+
+end

data/spec/seed_data/test_data_set/people.yml

@@ -0,0 +1,18 @@
+- id: 1
+  first_name: Joe
+  last_name: Smith
+  company_id: 1
+  start_date: <%= 2.months.ago.to_date %>
+
+- id: 2
+  first_name: Jane
+  last_name: Doe
+  company_id: 1
+  start_date: <%= 10.months.ago.to_date %>
+
+- id: 3
+  first_name: John
+  last_name: Walsh
+  company_id: 2
+  start_date: <%= 10.years.ago.to_date %>
+

metadata

@@ -0,0 +1,130 @@
+--- !ruby/object:Gem::Specification
+name: application_seeds
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- John Wood
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A library for managing standardized application seed data
+email:
+- john.wood@centro.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- application_seeds.gemspec
+- lib/application_seeds.rb
+- lib/application_seeds/attributes.rb
+- lib/application_seeds/capistrano.rb
+- lib/application_seeds/database.rb
+- lib/application_seeds/version.rb
+- spec/application_seeds_spec.rb
+- spec/seed_data/test_data_set/people.yml
+homepage: https://github.com/centro/application_seeds
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -2100833736178153226
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -2100833736178153226
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: A library for managing a standardized set of seed data for applications in
+  a non-production environment
+test_files:
+- spec/application_seeds_spec.rb
+- spec/seed_data/test_data_set/people.yml