mongoid-fixture_set 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 297ec45702b1e85a83fda02e8be090acaac190ea
+  data.tar.gz: d6d94d95f55e846592e4db664076c0b9ab0003b5
+SHA512:
+  metadata.gz: e6f4172a8e2718ff390cab895326a909d9cf3d04b15a087118ccb416a91ad18ad3a80c2efae8173729fbed1390fb69fc171466d12482bb75fca06e68b5975694
+  data.tar.gz: cda8caed33dd8e1362a503f59e62d249a46e65547c9b987f1455e76438713642c4ea0be9dfaa2348280d7700898fd2e68a8027a3512296ed99fdc0e6c60653ca

data/Rakefile

@@ -0,0 +1,15 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+desc 'Default: run unit tests'
+task :default => :test
+
+desc 'Run tests'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+

data/lib/mongoid-fixture_set.rb

@@ -0,0 +1,2 @@
+require 'mongoid/fixture_set'
+

data/lib/mongoid/fixture_set.rb

@@ -0,0 +1,242 @@
+require 'mongoid/fixture_set/fixture'
+require 'mongoid/fixture_set/file'
+require 'mongoid/fixture_set/class_cache'
+require 'mongoid/fixture_set/test_helper'
+
+require 'active_support/core_ext/digest/uuid'
+
+module Mongoid
+  class FixtureSet
+    @@cached_fixtures = Hash.new
+
+    cattr_accessor :all_loaded_fixtures
+    self.all_loaded_fixtures = {}
+
+    class << self
+      def context_class
+        @context_class ||= Class.new
+      end
+
+      def cached_fixtures(keys_to_fetch = nil)
+        if keys_to_fetch
+          @@cached_fixtures.values_at(*keys_to_fetch)
+        else
+          @@cached_fixtures.values
+        end
+      end
+
+      def reset_cache
+        @@cached_fixtures.clear
+      end
+
+      def fixture_is_cached?(name)
+        @@cached_fixtures[name]
+      end
+
+      def cache_fixtures(fixtures_map)
+        @@cached_fixtures.update(fixtures_map)
+      end
+
+      def default_fixture_model_name(fixture_set_name)
+        fixture_set_name.singularize.camelize
+      end
+
+      def update_all_loaded_fixtures(fixtures_map)
+        all_loaded_fixtures.update(fixtures_map)
+      end
+
+      def create_fixtures(fixtures_directory, fixture_set_names, class_names = {})
+        fixture_set_names = Array(fixture_set_names).map(&:to_s)
+        class_names = ClassCache.new(class_names)
+
+        files_to_read = fixture_set_names.reject { |fs_name|
+          fixture_is_cached?(fs_name)
+        }
+
+        if files_to_read.empty?
+          return cached_fixtures(fixture_set_names)
+        end
+
+        fixtures_map = {}
+        fixture_sets = files_to_read.map do |fs_name|
+          klass = class_names[fs_name]
+          fixtures_map[fs_name] = Mongoid::FixtureSet.new(
+                                      fs_name,
+                                      klass,
+                                      ::File.join(fixtures_directory, fs_name))
+        end
+
+        update_all_loaded_fixtures fixtures_map
+
+        fixture_sets.each do |fs|
+          fs.collection_documents.each do |model, documents|
+            model = class_names[model]
+            if model
+              documents.each do |attributes|
+                create_or_update_document(model, attributes)
+              end
+            end
+          end
+        end
+
+        cache_fixtures(fixtures_map)
+
+        return cached_fixtures(fixture_set_names)
+      end
+
+      def create_or_update_document(model, attributes)
+        document = model.find_or_initialize_by('_id' => attributes['_id'])
+        keys = (attributes.keys + document.attributes.keys).uniq
+        attrs = Hash[keys.collect do |key|
+          if attributes[key].is_a?(Array) || document.attributes[key].is_a?(Array)
+            value = [attributes[key], document.attributes[key]].flatten(1).compact
+          else
+            value = attributes[key] || document.attributes[key]
+          end
+          [key, value]
+        end]
+        document.assign_attributes(attrs)
+        document.save(validate: false)
+      end
+
+      # Returns a consistent, platform-independent identifier for +label+.
+      # UUIDs are RFC 4122 version 5 SHA-1 hashes.
+      def identify(model, label)
+        Digest::UUID.uuid_v5(Digest::UUID::OID_NAMESPACE, "#{model}##{label}")
+      end
+    end
+
+    attr_reader :name, :path, :model_class, :class_name
+    attr_reader :fixtures
+
+    def initialize(name, class_name, path)
+      @name = name
+      @path = path
+
+      if class_name.is_a?(Class)
+        @model_class = class_name
+      elsif class_name
+        @model_class = class_name.safe_constantize
+      end
+
+      @class_name = @model_class.respond_to?(:name) ?
+        @model_class.name :
+        self.class.default_fixture_model_name(name)
+
+      @fixtures = read_fixture_files
+    end
+
+    def [](x)
+      fixtures[x]
+    end
+
+    # Returns a hash of documents to be inserted. The key is the model class, the value is
+    # a list of documents to insert in th relative collection.
+    def collection_documents
+      # allow a standard key to be used for doing defaults in YAML
+      fixtures.delete('DEFAULTS')
+
+      # track any join collection we need to insert later
+      documents = Hash.new
+
+      documents[class_name] = fixtures.map do |label, fixture|
+        attributes = fixture.to_hash
+
+        next attributes if model_class.nil?
+
+        set_attributes_timestamps(attributes, model_class)
+        
+        # interpolate the fixture label
+        attributes.each do |key, value|
+          attributes[key] = value.gsub("$LABEL", label) if value.is_a?(String)
+        end
+
+        attributes['_id'] = self.class.identify(class_name, label)
+
+        model_class.relations.each do |name, relation|
+          case relation.macro
+          when :belongs_to
+            if value = attributes.delete(relation.name.to_s)
+              id = self.class.identify(relation.class_name, value)
+              if relation.polymorphic? && value.sub!(/\s*\(([^)]*)\)\s*/, '')
+                type = $1
+                attributes[relation.foreign_key.sub(/_id$/, '_type')] = type
+                id = self.class.identify(type, value)
+              end
+              attributes[relation.foreign_key] = id
+            end
+          when :has_many
+            if values = attributes.delete(relation.name.to_s)
+              values.each do |value|
+                id = self.class.identify(relation.class_name, value)
+                if relation.polymorphic?
+                  self.class.create_or_update_document(relation.class_name.constantize, {
+                    '_id' => id,
+                    "#{relation.as}_id" => attributes['_id'],
+                    "#{relation.as}_type" => model_class.name,
+                  })
+                else
+                  self.class.create_or_update_document(relation.class_name.constantize, {
+                    '_id' => id,
+                    relation.foreign_key => attributes['_id'],
+                  })
+                end
+              end
+            end
+          when :has_and_belongs_to_many
+            if values = attributes.delete(relation.name.to_s)
+              key = "#{relation.name.to_s.singularize}_ids"
+              attributes[key] = []
+
+              values.each do |value|
+                id = self.class.identify(relation.class_name, value)
+                attributes[key] << id
+
+                self.class.create_or_update_document(relation.class_name.constantize, {
+                  '_id' => id,
+                  relation.inverse_foreign_key => [attributes['_id']]
+                })
+              end
+            end
+          end
+        end
+
+        attributes
+      end
+
+      return documents
+    end
+
+    private
+    def set_attributes_timestamps(attributes, model_class)
+      now = Time.now.utc
+
+      if model_class < Mongoid::Timestamps::Created::Short
+        attributes['c_at'] = now        unless attributes.has_key?('c_at')
+      elsif model_class < Mongoid::Timestamps::Created
+        attributes['created_at'] = now  unless attributes.has_key?('created_at')
+      end
+
+      if model_class < Mongoid::Timestamps::Updated::Short
+        attributes['u_at'] = now        unless attributes.has_key?('u_at')
+      elsif model_class < Mongoid::Timestamps::Updated
+        attributes['updated_at'] = now  unless attributes.has_key?('updated_at')
+      end
+    end
+
+    def read_fixture_files
+      yaml_files = Dir["#{path}/{**,*}/*.yml"].select { |f|
+        ::File.file?(f)
+      } + ["#{path}.yml"]
+
+      yaml_files.each_with_object({}) do |file, fixtures|
+        Mongoid::FixtureSet::File.open(file) do |fh|
+          fh.each do |fixture_name, row|
+            fixtures[fixture_name] = Mongoid::FixtureSet::Fixture.new(fixture_name, row, model_class)
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/mongoid/fixture_set/class_cache.rb

@@ -0,0 +1,29 @@
+class ClassCache
+  def initialize(class_names)
+    @class_names = class_names.stringify_keys
+    # Remove string values that aren't constants or subclasses of Mongoid::Document
+    @class_names.delete_if { |klass_name, klass| !insert_class(@class_names, klass_name, klass) }
+  end
+
+  def [](fs_name)
+    @class_names.fetch(fs_name) {
+      klass = default_fixture_model(fs_name).safe_constantize
+      insert_class(@class_names, fs_name, klass)
+    }
+  end
+
+  private
+  def insert_class(class_names, name, klass)
+    # We only want to deal with Mongoid objects.
+    if klass && klass < Mongoid::Document
+      class_names[name] = klass
+    else
+      class_names[name] = nil
+    end
+  end
+
+  def default_fixture_model(fs_name)
+    Mongoid::FixtureSet.default_fixture_model_name(fs_name)
+  end
+end
+

data/lib/mongoid/fixture_set/errors.rb

@@ -0,0 +1,13 @@
+module Mongoid
+  class FixtureSet
+    class FixtureError < Mongoid::Errors::MongoidError
+    end
+
+    class FormatError < FixtureError
+    end
+
+    class FixtureClassNotFound < FixtureError
+    end
+  end
+end
+

data/lib/mongoid/fixture_set/file.rb

@@ -0,0 +1,61 @@
+require 'erb'
+require 'yaml'
+
+module Mongoid
+  class FixtureSet
+
+    class RenderContext
+      def self.create_subclass
+        Class.new Mongoid::FixtureSet.context_class do
+          def get_binding
+            binding()
+          end
+        end
+      end
+    end
+
+    class Mongoid::FixtureSet::File # :nodoc:
+      include Enumerable
+
+      def self.open(file)
+        x = new file
+        block_given? ? yield(x) : x
+      end
+
+      def initialize(file)
+        @file = file
+        @rows = nil
+      end
+
+      def each(&block)
+        rows.each(&block)
+      end
+
+      private
+      def rows
+        return @rows if @rows
+        begin
+          data = YAML.load(render(IO.read(@file)))
+        rescue ArgumentError, Psych::SyntaxError => error
+          raise FormatError, "a YAML error occurred parsing #{@file}. Please note that YAML must be consistently indented using spaces. Tabs are not allowed. Please have a look at http://www.yaml.org/faq.html\nThe exact error was:\n #{error.class}: #{error}", error.backtrace
+        end
+        @rows = data ? validate(data).to_a : []
+      end
+
+      def render(content)
+        context = RenderContext.create_subclass.new
+        ERB.new(content).result(context.get_binding)
+      end
+
+      # Validate our unmarshalled data.
+      def validate(data)
+        unless Hash === data || YAML::Omap === data
+          raise FormatError, 'fixture is not a hash'
+        end
+        raise FormatError unless data.all? { |name, row| Hash === row }
+        data
+      end
+    end
+  end
+end
+

data/lib/mongoid/fixture_set/fixture.rb

@@ -0,0 +1,41 @@
+require 'mongoid/fixture_set/errors'
+
+module Mongoid
+  class FixtureSet
+    class Fixture
+      include Enumerable
+
+      attr_reader :name, :fixture, :model_class
+      def initialize(name, fixture, model_class)
+        @name         = name
+        @fixture      = fixture
+        @model_class  = model_class
+      end
+
+      def class_name
+        model_class.name if model_class
+      end
+
+      def each
+        fixture.each { |item| yield item }
+      end
+
+      def [](key)
+        fixture[key]
+      end
+
+      alias :to_hash :fixture
+
+      def find
+        if model_class
+          model_class.unscoped do
+            model_class.find(Mongoid::FixtureSet.identify(model_class, name))
+          end
+        else
+          raise FixtureClassNotFound, "No class attached to find."
+        end
+      end
+    end
+  end
+end 
+

data/lib/mongoid/fixture_set/test_helper.rb

@@ -0,0 +1,88 @@
+require 'active_support/concern'
+
+module Mongoid
+  class FixtureSet
+    module TestHelper
+      extend ActiveSupport::Concern
+
+      def before_setup
+        setup_fixtures
+        super
+      end
+
+      def after_teardown
+        super
+        teardown_fixtures
+      end
+
+      included do
+        class_attribute :fixture_path, :instance_writer => false
+        class_attribute :fixture_set_names
+
+        self.fixture_set_names = []
+      end
+
+      module ClassMethods
+       def fixtures(*fixture_set_names)
+         if fixture_set_names.first == :all
+           fixture_set_names = Dir["#{fixture_path}/{**,*}/*.{yml}"]
+           fixture_set_names.map! { |f| f[(fixture_path.to_s.size + 1)..-5] }
+         else
+           fixture_set_names = fixture_set_names.flatten.map(&:to_s)
+         end
+         self.fixture_set_names |= fixture_set_names
+         setup_fixture_accessors(fixture_set_names)
+       end
+
+       def setup_fixture_accessors(fixture_set_names = nil)
+         fixture_set_names = Array(fixture_set_names || self.fixture_set_names)
+         methods = Module.new do
+           fixture_set_names.each do |fs_name|
+             fs_name = fs_name.to_s
+             accessor_name = fs_name.tr('/', '_').to_sym
+             define_method(accessor_name) do |*fixture_names|
+               force_reload = fixture_names.pop if fixture_names.last == true || fixture_names.last == :reload
+               @fixture_cache[fs_name] ||= {}
+               instances = fixture_names.map do |f_name|
+                 f_name = f_name.to_s
+                 @fixture_cache[fs_name].delete(f_name) if force_reload
+                 if @loaded_fixtures[fs_name] && @loaded_fixtures[fs_name][f_name]
+                   @fixture_cache[fs_name][f_name] ||= @loaded_fixtures[fs_name][f_name].find
+                 else
+                   raise StandardError, "No fixture named '#{f_name}' found for fixture set '#{fs_name}'"
+                 end
+               end
+               instances.size == 1 ? instances.first : instances
+             end
+             private accessor_name
+           end
+         end
+         include methods
+       end
+      end
+
+      def setup_fixtures
+        @fixture_cache = {}
+
+        Mongoid::FixtureSet.reset_cache
+        @loaded_fixtures = load_fixtures
+      end
+
+      def teardown_fixtures
+        Mongoid::FixtureSet.reset_cache
+      end
+
+      private
+      def load_fixtures
+        fixture_set_names = self.class.fixture_set_names
+        if fixture_set_names.empty?
+          self.class.fixtures(:all)
+          fixture_set_names = self.class.fixture_set_names
+        end
+        fixtures = Mongoid::FixtureSet.create_fixtures(fixture_path, fixture_set_names)
+        Hash[fixtures.map { |f| [f.name, f] }]
+      end
+    end
+  end
+end
+

data/lib/mongoid/fixture_set/version.rb

@@ -0,0 +1,6 @@
+module Mongoid
+  class FixtureSet
+    VERSION = '1.0.0'
+  end
+end
+

data/test/fixtures/groups.yml

@@ -0,0 +1,11 @@
+sudoers:
+  name: Sudoers!
+  something: orga1 (Organisation)
+print:
+  name: Print
+  users:
+    - user1
+group1:
+  name: Margot
+  main_users:
+    - user1

data/test/fixtures/not_models.yml

@@ -0,0 +1,2 @@
+error:
+  name: Does not exist?

data/test/fixtures/organisations.yml

@@ -0,0 +1,4 @@
+orga1:
+  name: <%= '1 Organisation' %>
+  groups:
+    - print

data/test/fixtures/schools.yml

@@ -0,0 +1,9 @@
+school:
+  name: School
+  groups:
+    - group1
+<% 5.times do |i| %>
+school<%= i %>:
+  name: School <%= i %>
+<% end %>
+

data/test/fixtures/users.yml

@@ -0,0 +1,9 @@
+geoffroy:
+  firstname: Geoffroy
+  lastname: Planquart
+  main_group: sudoers
+  groups:
+    - print
+user1:
+  firstname: Margot
+  lastname: Last

data/test/fixtures/users/family.yml

@@ -0,0 +1,4 @@
+dad:
+  firstname: Dad
+mom:
+  firstname: Mom

data/test/models/group.rb

@@ -0,0 +1,13 @@
+class Group
+  include Mongoid::Document
+  include Mongoid::Timestamps::Created::Short
+
+  field :name
+
+  has_many :main_users, class_name: 'User', inverse_of: :main_group
+
+  has_and_belongs_to_many :users
+
+  belongs_to :something, polymorphic: true
+end
+

data/test/models/organisation.rb

@@ -0,0 +1,9 @@
+class Organisation
+  include Mongoid::Document
+  include Mongoid::Timestamps::Created
+
+  field :name
+
+  has_many :groups, as: :something
+end
+

data/test/models/school.rb

@@ -0,0 +1,9 @@
+class School
+  include Mongoid::Document
+  include Mongoid::Timestamps::Updated
+
+  field :name
+
+  has_many :groups, as: :something
+end
+

data/test/models/user.rb

@@ -0,0 +1,12 @@
+class User
+  include Mongoid::Document
+  include Mongoid::Timestamps::Updated::Short
+
+  field :firstname
+  field :lastname
+
+  belongs_to :main_group, class_name: 'Group', inverse_of: :main_users
+
+  has_and_belongs_to_many :groups
+end
+

data/test/mongoid.yml

@@ -0,0 +1,6 @@
+test:
+  sessions:
+    default:
+      database: mongoid_fixture_set_test
+      hosts:
+        - localhost:27017

data/test/mongoid/fixture_set_test.rb

@@ -0,0 +1,72 @@
+require 'test_helper'
+require 'pry'
+
+module Mongoid
+  class FixtureSetTest < BaseTest
+    def test_should_initialize_fixture_set
+      Mongoid::FixtureSet.reset_cache
+      fs = Mongoid::FixtureSet.new('users', 'User', 'test/fixtures/users')
+      assert_equal User, fs.model_class
+      fixture = fs['geoffroy']
+      assert_equal 'User', fixture.class_name
+      assert_equal 'Geoffroy', fixture['firstname']
+      assert_equal 'Planquart', fixture['lastname']
+    end
+
+    def test_should_not_create_fixtures
+      Mongoid::FixtureSet.reset_cache
+      fs = Mongoid::FixtureSet.create_fixtures('test/fixtures/', [])
+      assert_equal 0, fs.count
+    end
+
+    def test_should_create_not_model_fixture
+      Mongoid::FixtureSet.reset_cache
+      fs = Mongoid::FixtureSet.create_fixtures('test/fixtures', %w(not_models))
+      fs = fs.first
+      fixture = fs['error']
+
+      begin
+        fixture.find
+        assert false, 'No exception has been raised'
+      rescue Mongoid::FixtureSet::FixtureClassNotFound
+        assert true
+      end
+    end
+
+    def test_should_create_fixtures
+      Mongoid::FixtureSet.reset_cache
+      fs = Mongoid::FixtureSet.create_fixtures('test/fixtures/', %w(users groups schools organisations))
+
+      users = fs.find{|x| x.model_class == User}
+      f_geoffroy = users['geoffroy']
+
+      assert_equal 6, School.count
+      assert_equal 4, User.count
+
+      geoffroy = User.find_by(firstname: 'Geoffroy')
+      user1 = User.find_by(firstname: 'Margot')
+      sudoers = Group.find_by(name: 'Sudoers!')
+      print = Group.find_by(name: 'Print')
+      group1 = Group.find_by(name: 'Margot')
+      orga1 = Organisation.find_by(name: '1 Organisation')
+      school = School.find_by(name: 'School')
+
+      assert_equal geoffroy, f_geoffroy.find
+      assert_equal 2, print.users.count
+      assert print.users.include?(geoffroy)
+      assert print.users.include?(user1)
+      assert sudoers.main_users.include?(geoffroy)
+      assert_equal group1, user1.main_group
+      assert_equal print, user1.groups.first
+
+      assert_equal 1, school.groups.count
+      assert_equal group1, school.groups.first
+      assert_equal school, group1.something
+
+      assert_equal 2, orga1.groups.count
+      assert orga1.groups.include?(sudoers)
+      assert_equal orga1, sudoers.something
+    end
+  end
+end
+

data/test/mongoid/fixtures_test.rb

@@ -0,0 +1,15 @@
+class FixturesTest < BaseTest
+  include Mongoid::FixtureSet::TestHelper
+  self.fixture_path = 'test/fixtures'
+
+  def test_should_access_fixtures
+    begin
+      geoffroy = users(:geoffroy)
+      assert true
+    rescue
+      assert false, 'An exception was thrown'
+    end
+  end
+end
+
+

data/test/test_helper.rb

@@ -0,0 +1,22 @@
+require 'bundler/setup'
+require 'simplecov'
+SimpleCov.configure do
+  add_filter '/test/'
+end
+SimpleCov.start if ENV['COVERAGE']
+
+require 'minitest/autorun'
+require 'mongoid'
+
+require File.expand_path("../../lib/mongoid-fixture_set", __FILE__)
+
+Mongoid.load!("#{File.dirname(__FILE__)}/mongoid.yml", "test")
+
+Dir["#{File.dirname(__FILE__)}/models/*.rb"].each { |f| require f }
+
+class BaseTest < ActiveSupport::TestCase
+  def teardown
+    Mongoid::Sessions.default.use('mongoid_fixture_set_test').drop
+  end
+end
+

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification
+name: mongoid-fixture_set
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Geoffroy Planquart
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mongoid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: Let you use fixtures with Mongoid the same way you did with ActiveRecord
+email:
+- geoffroy@planquart.fr
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/mongoid/fixture_set/version.rb
+- lib/mongoid/fixture_set/errors.rb
+- lib/mongoid/fixture_set/file.rb
+- lib/mongoid/fixture_set/class_cache.rb
+- lib/mongoid/fixture_set/test_helper.rb
+- lib/mongoid/fixture_set/fixture.rb
+- lib/mongoid/fixture_set.rb
+- lib/mongoid-fixture_set.rb
+- Rakefile
+- test/mongoid/fixtures_test.rb
+- test/mongoid/fixture_set_test.rb
+- test/models/group.rb
+- test/models/organisation.rb
+- test/models/school.rb
+- test/models/user.rb
+- test/mongoid.yml
+- test/fixtures/users.yml
+- test/fixtures/groups.yml
+- test/fixtures/schools.yml
+- test/fixtures/organisations.yml
+- test/fixtures/users/family.yml
+- test/fixtures/not_models.yml
+- test/test_helper.rb
+homepage: https://github.com/Aethelflaed/mongoid-fixture_set
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Fixtures for Mongoid
+test_files:
+- test/mongoid/fixtures_test.rb
+- test/mongoid/fixture_set_test.rb
+- test/models/group.rb
+- test/models/organisation.rb
+- test/models/school.rb
+- test/models/user.rb
+- test/mongoid.yml
+- test/fixtures/users.yml
+- test/fixtures/groups.yml
+- test/fixtures/schools.yml
+- test/fixtures/organisations.yml
+- test/fixtures/users/family.yml
+- test/fixtures/not_models.yml
+- test/test_helper.rb
+has_rdoc: