fixture_tree 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1dcb06bf0cff5a0bf61e4fb25d05747287af2924
+  data.tar.gz: 5cde802d2ccc3684465aa871fcb3e374fc559fd5
+SHA512:
+  metadata.gz: 558ec567790defbd8ca976d7e7fe94918f51c069aa0c0c89b82bd18335761e68b3af2c7321deeab6cf5ae6ba506e133c6a1a30ae83985708d144eb135adf418a
+  data.tar.gz: da234c94add70c0baaf9c08f0ed423265ec2ea146e4154fb843836fc73e4dd536b9446ea307d56fb8ba172d00fbbca9dc594cf8c964bc5c6dce9147983ad3513

data/lib/fixture_tree.rb

@@ -0,0 +1,141 @@
+# Helper for creating directory hierarchies to use with tests.
+#
+# You'll typically create trees with `FixtureTree.create`. If you're using RSpec, put this inside one of your specs:
+#
+#   around do |example|
+#     FixtureTree.create do |tree|
+#       @tree = tree
+#       example.run
+#     end
+#   end
+#
+# Now put some data into your tree:
+#
+#   before do
+#     @tree.merge({
+#       'one' => 'two', # keys can be either strings...
+#       three: 'four',  # ...or symbols
+#       five: {         # create nested directories by using a hash
+#         six: 'seven'
+#       }
+#     })
+#   end
+#
+# And test against it:
+#
+#   it "has a file named 'one' whose contents are 'two'" do
+#     expect(@tree.path.join('one').open.read).to eq('two') # FixtureTree#path returns a Pathname object
+#   end
+#
+#   it "has a nested directory named 'five' with a file named 'six' whose contents are 'seven'" do
+#     expect(@tree.path.join('five/six').open.read).to eq('seven')
+#   end
+#
+# You can add additional files if a test calls for them:
+#
+#   it 'lets me add additional files and keeps existing ones around' do
+#     @tree.merge({
+#       'eight.txt' => 'nine'
+#     })
+#     expect(@tree.path.join('eight.txt').open.read).to eq('nine')
+#     expect(@tree.path.join('one').open.read).to eq('two')
+#   end
+#
+# Or you can replace the entire tree:
+#
+#   it 'lets me replace the entire tree' do
+#     @tree.replace({
+#       ten: 'eleven'
+#     })
+#     expect(@tree.path.join('ten').open.read).to eq('eleven')
+#     expect(@tree.path.join('one').exist?).to be(false)
+#   end
+#
+# The tree will be automatically deleted when your `FixtureTree#create` block exits.
+class FixtureTree
+  attr_reader :path
+
+  # Wrap the specified `Pathname` instance with a `FixtureTree` that can be used to modify it. No special cleanup will
+  # be undertaken after you're done testing if you create a `FixtureTree` this way, so you'll need to make sure to
+  # delete it after you're done with it.
+  def initialize(path)
+    @path = path
+  end
+
+  # Create an ephemeral `FixtureTree`.
+  #
+  # If a block is given, the tree will be yielded to the block, and the tree's data (including any modifications made
+  # to it during the course of testing) will be deleted when the block exits. If not, `[dir, tree]` will be returned,
+  # where `dir` is a Pathname object pointing to a temporary directory containing the tree and `tree` is the ephemeral
+  # `FixtureTree` object. The tree's contents can be cleaned up by deleting `dir` after testing is complete.
+  def self.create
+    temp_dir = Pathname.new(Dir.mktmpdir('fixture_tree'))
+    tree = FixtureTree.new(temp_dir.join('fixture'))
+
+    if block_given?
+      begin
+        yield FixtureTree.new(temp_dir.join('fixture'))
+      ensure
+        temp_dir.rmtree if temp_dir.exist?
+      end
+    else
+      [temp_dir, tree]
+    end
+  end
+
+  # Merge the given directory hierarchy or file into this `FixtureTree`.
+  #
+  # `data` can be either a string or a hash. If it's a hash, this `FixtureTree` will be created as a directory if it's
+  # not already one and a file or directory created for each entry in the hash. Values can themselves be strings or
+  # hashes to create nested files or directories, respectively. If it's a string, this `FixtureTree` will be created
+  # as a file whose contents are the specified string.
+  def merge(data)
+    if data.is_a?(Hash)
+      delete unless @path.directory?
+      @path.mkpath
+
+      data.each do |name, contents|
+        join(name.to_s).merge(contents)
+      end
+    else
+      delete
+      @path.write(data)
+    end
+
+    self
+  end
+
+  # Replace this `FixtureTree` with the specified directory hierarchy or file. This is equivalent to calling `delete`
+  # followed by `merge(data)`.
+  def replace(data)
+    delete
+    merge(data)
+
+    self
+  end
+
+  # Deletes this `FixtureTree`, if it exists. If this tree is currently a directory, it will be removed along with its
+  # children. If this tree is currently a file, the file will be deleted.
+  #
+  # `merge` or `replace` can later be called to recreate this `FixtureTree`.
+  def delete
+    if @path.directory?
+      @path.rmtree
+    elsif @path.exist?
+      @path.delete
+    end
+
+    self
+  end
+
+  # Return a `FixtureTree` offering a view on a nested path of this `FixtureTree`. This can be used like:
+  #
+  #   some_tree.join('foo/bar').merge({'baz' => 'qux'})
+  #
+  # to get the same effect as:
+  #
+  #   some_tree.merge({'foo' => {'bar' => {'baz' => 'qux'}}})
+  def join(path)
+    FixtureTree.new(@path.join(path))
+  end
+end

data/lib/fixture_tree/rspec_support.rb

@@ -0,0 +1,112 @@
+class FixtureTree
+  # RSpec helpers to make testing with FixtureTree even easier.
+  #
+  # Extend RSpecSupport in a test:
+  #
+  #   RSpec.describe 'something' do
+  #     extend FixtureTree::RSpecSupport
+  #
+  #     # specs here
+  #   end
+  #
+  # Or include it in all your tests:
+  #
+  #   RSpec.configure do |c|
+  #     c.extend RSpecSupport
+  #   end
+  #
+  # You can then declare trees using `fixture_tree`:
+  #
+  #   RSpec.describe 'something' do
+  #     fixture_tree :example_tree, data: {foo: 'bar'}
+  #
+  #     it "has a file named 'foo' whose contents are 'bar'" do
+  #       expect(example_tree.path.join('foo').open.read).to eq('bar')
+  #     end
+  #   end
+  #
+  # Trees can be populated in `before` hooks, if you like:
+  #
+  #   fixture_tree :example_tree
+  #
+  #   before(:each) do
+  #     example_tree.merge({foo: 'bar'})
+  #   end
+  #
+  #   it "has a file named 'foo' whose contents are 'bar'" do
+  #     expect(example_tree.path.join('foo').open.read).to eq('bar')
+  #   end
+  #
+  # Nested contexts can overwrite trees:
+  #
+  #   fixture_tree :example_tree, data: {foo: 'bar'}
+  #
+  #   it "has a file named 'foo'" do
+  #     expect(example_tree.path.children.map(&:basename)).to contain_exactly('foo')
+  #   end
+  #
+  #   context 'with a different set of files' do
+  #     fixture_tree :example_tree, data: {baz: 'qux'}
+  #
+  #     it "only has a file named 'baz'" do
+  #       expect(example_tree.path.children.map(&:basename)).to contain_exactly('baz')
+  #     end
+  #   end
+  #
+  # Or you can include `merge: true` to merge with the parent context's tree:
+  #
+  #   fixture_tree :example_tree, data: {foo: 'bar'}
+  #
+  #   it "has a file named 'foo'" do
+  #     expect(example_tree.path.children.map(&:basename)).to contain_exactly('foo')
+  #   end
+  #
+  #   context 'with an additional file' do
+  #     fixture_tree :example_tree, merge: true, data: {baz: 'qux'}
+  #
+  #     it "has files named 'foo' and 'baz'" do
+  #       expect(example_tree.path.children.map(&:basename)).to contain_exactly('foo', 'baz')
+  #     end
+  #   end
+  #
+  # And that's about it.
+  module RSpecSupport
+    def fixture_tree(name, data: nil, merge: false, eager: false)
+      # eager intentionally left undocumented because it's not actually useful until I implement support for running
+      # hooks when a tree is instantiated
+      let(name) do
+        if merge && defined?(super)
+          # asked to merge and super is defined. we'll assume it's a tree from an outer context and merge into it
+          # instead of creating a new tree.
+          tree = super()
+        else
+          # either our parent context doesn't define a tree or we weren't asked to merge with it, so create a new one.
+          temp_dir, tree = FixtureTree.create
+
+          # store the temp dir so that we can clean it up after the test completes
+          instance_variable_set(:"@_fixture_tree_dir_#{name}", temp_dir)
+        end
+
+        if data
+          tree.merge(data)
+        end
+      end
+
+      if eager
+        before do
+          send(name)
+        end
+      end
+
+      after do
+        # clean up the temp dir if we still know about one
+        if instance_variable_defined?(:"@_fixture_tree_dir_#{name}")
+          # delete it
+          instance_variable_get(:"@_fixture_tree_dir_#{name}").rmtree
+          # then unset it so that we won't accidentally try to clean it up in a parent context
+          remove_instance_variable(:"@_fixture_tree_dir_#{name}")
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,45 @@
+--- !ruby/object:Gem::Specification
+name: fixture_tree
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Alex Boyd
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-10-18 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: aboyd@instructure.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/fixture_tree.rb
+- lib/fixture_tree/rspec_support.rb
+homepage: https://github.com/instructure/fixture_tree
+licenses: []
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Helper for creating directory hierarchies to use with tests
+test_files: []
+has_rdoc: