repo-fixture 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4ab1242b730e36cda5acc34c41384546058ce03f
+  data.tar.gz: 4d1bb0ce70eb1a541023a56848317f7d00bc6162
+SHA512:
+  metadata.gz: ab1cbad9f3af721fcf77ddf93d6238492298bed6e0d1e6220b32eefe1cd9c93a6b1de91405a071587764fd77681a4c8947883c42fabb1539e1fae79e2c5340ac
+  data.tar.gz: 77509df96d653ffba83baec0491fa609ad03b0bda97d6687ae9a822c9cc188fa8bc4d3fb89b88a5b319840ecc96f33f76daaaee15efc4d23ec26f0e3d88d6df8

data/Gemfile

@@ -0,0 +1,13 @@
+source "https://rubygems.org"
+
+gemspec
+
+group :development, :test do
+  gem 'pry-nav'
+  gem 'rake'
+end
+
+group :test do
+  gem 'rspec'
+  gem 'rr'
+end

data/History.txt

@@ -0,0 +1,3 @@
+== 1.0.0
+
+* Birthday!

data/README.md

@@ -0,0 +1,70 @@
+repo-fixture
+============
+
+Build and package up git repositories as test fixtures.
+
+## Installation
+
+`gem install repo-fixture`
+
+## Usage
+
+```ruby
+require 'repo-fixture'
+```
+
+### Philosophy
+
+Test fixtures are static files that contain data used in tests. For example, you might be writing and testing a YAML parser that needs to recognize various types of YAML data. You could test these various types by creating a number of .yml fixture files that you then feed to your parser.
+
+RepoFixture brings this concept to git repositories. It facilitates creating and packaging the repositories into individual fixture files (currently only zip is supported). RepoFixture can also load fixture files and expand the repo's contents into your temp folder, creating a pristine test environment every time.
+
+### Generating Fixtures
+
+To create a new repo-based fixture:
+
+```ruby
+my_fixture = RepoFixture.create do |fixture|
+  fixture.copy_files(Dir.glob('path/to/files/**/**')) do |file|
+    file.sub('path/to/files', '')  # the path in the zip file itself
+  end
+
+  fixture.add_all
+  fixture.commit('Committing all files')
+end
+```
+
+Note that the `fixture` object in the example above responds to all the methods in [`TmpRepo`](https://github.com/camertron/tmp-repo).
+
+Once you've put your fixture repo into the state you want, use the `export` method to generate a fixture file:
+
+```ruby
+my_fixture.export('path/to/my_fixture.zip')
+```
+
+It's always a good idea to clean up after yourself as well:
+
+```ruby
+my_fixture.unlink
+```
+
+### Loading Fixtures
+
+Once you've created a fixture file, you might want to load it again:
+
+```ruby
+my_fixture = RepoFixture.load('./path/to/my_fixture.zip')
+my_fixture.working_dir  # => somewhere in your tmp directory
+```
+
+## Requirements
+
+No external requirements.
+
+## Running Tests
+
+`bundle exec rake` should do the trick.
+
+## Authors
+
+* Cameron C. Dutro: http://github.com/camertron

data/Rakefile

@@ -0,0 +1,18 @@
+# encoding: UTF-8
+
+require 'rubygems' unless ENV['NO_RUBYGEMS']
+
+require 'bundler'
+require 'rspec/core/rake_task'
+require 'rubygems/package_task'
+
+require './lib/repo-fixture'
+
+Bundler::GemHelper.install_tasks
+
+task :default => :spec
+
+desc 'Run specs'
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = './spec/**/*_spec.rb'
+end

data/lib/repo-fixture.rb

@@ -0,0 +1,33 @@
+# encoding: UTF-8
+
+require 'tmp-repo'
+
+module RepoFixture
+  autoload :Fixture,     'repo-fixture/fixture'
+  autoload :ZipStrategy, 'repo-fixture/zip_strategy'
+
+  def self.create
+    fixture = Fixture.new(TmpRepo.new)
+    yield fixture
+    fixture
+  end
+
+  def self.load(file, strategy = Fixture::DEFAULT_STRATEGY)
+    strategy_class_for(strategy).load(file)
+  end
+
+  def self.strategy_class_for(strategy)
+    const_str = "#{camelize(strategy.to_s)}Strategy"
+    if RepoFixture.const_defined?(const_str)
+      RepoFixture.const_get(const_str)
+    else
+      raise ArgumentError, "'#{strategy}' isn't a valid export strategy."
+    end
+  end
+
+  private
+
+  def self.camelize(str)
+    str.gsub(/(^\w|[-_]\w)/) { $1[-1].upcase }
+  end
+end

data/lib/repo-fixture/fixture.rb

@@ -0,0 +1,55 @@
+# encoding: UTF-8
+
+require 'fileutils'
+
+module RepoFixture
+
+  class Fixture
+    DEFAULT_STRATEGY = :zip
+
+    attr_reader :repo
+
+    def initialize(repo)
+      @repo = repo
+    end
+
+    # Copies files into the repo.
+    # Optional block receives each file, return value is the desired path inside the archive.
+    def copy_files(files)
+      Array(files).each do |file|
+        output_file = if block_given?
+          yield file
+        else
+          file
+        end
+
+        output_file = File.join(repo.working_dir, output_file)
+        FileUtils.mkdir_p(File.dirname(output_file))
+        FileUtils.cp(file, output_file)
+      end
+    end
+
+    def respond_to?(method)
+      repo.respond_to?(method)
+    end
+
+    def method_missing(method, *args, &block)
+      repo.send(method, *args, &block)
+    end
+
+    def export(export_file, strategy = DEFAULT_STRATEGY)
+      strategy_class_for(strategy).export(export_file, self)
+    end
+
+    def sh(command)
+      repo.in_repo { `#{command}` }
+    end
+
+    private
+
+    def strategy_class_for(strategy)
+      RepoFixture.strategy_class_for(strategy)
+    end
+  end
+
+end

data/lib/repo-fixture/version.rb

@@ -0,0 +1,5 @@
+# encoding: UTF-8
+
+module RepoFixture
+  VERSION = '1.0.0'
+end

data/lib/repo-fixture/zip_strategy.rb

@@ -0,0 +1,42 @@
+# encoding: UTF-8
+
+require 'zip'
+require 'fileutils'
+
+module RepoFixture
+  class ZipStrategy
+
+    class << self
+      def export(output_file, fixture)
+        repo = fixture.repo
+        working_dir_path_length = repo.working_dir.to_s.length
+        Zip::File.open(output_file, Zip::File::CREATE) do |zipfile|
+          Dir.glob("#{repo.working_dir}/**/**", File::FNM_DOTMATCH).each do |file|
+            if File.file?(file)
+              # plus 1 to remove the leading slash
+              relative_file = file[(working_dir_path_length + 1)..-1]
+              zipfile.add(relative_file, file)
+            end
+          end
+        end
+      end
+
+      def load(file)
+        output_dir = TmpRepo.random_dir
+
+        Zip::File.open(file) do |zipfile|
+          zipfile.each do |entry|
+            output_file = File.join(output_dir, entry.name)
+            FileUtils.mkdir_p(File.dirname(output_file))
+            entry.extract(output_file)
+          end
+        end
+
+        Fixture.new(
+          TmpRepo.new(output_dir)
+        )
+      end
+    end
+
+  end
+end

data/repo-fixture.gemspec

@@ -0,0 +1,21 @@
+$:.unshift File.join(File.dirname(__FILE__), 'lib')
+require 'repo-fixture/version'  
+
+Gem::Specification.new do |s|
+  s.name     = "repo-fixture"
+  s.version  = ::RepoFixture::VERSION
+  s.authors  = ["Cameron Dutro"]
+  s.email    = ["camertron@gmail.com"]
+  s.homepage = "http://github.com/camertron"
+
+  s.description = s.summary = "Build and package up git repositories as test fixtures."
+
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+
+  s.add_dependency 'tmp-repo', '~> 1.0.1'
+  s.add_dependency 'rubyzip', '~> 1.1.0'
+
+  s.require_path = 'lib'
+  s.files = Dir["{lib,spec}/**/*", "Gemfile", "History.txt", "README.md", "Rakefile", "repo-fixture.gemspec"]
+end

data/spec/fixture_files/moar_test.coffee

@@ -0,0 +1,6 @@
+class HelloWorld
+  foo: ->
+    console.log('foo')
+
+  bar: ->
+    console.log('bar')

data/spec/fixture_files/test.rb

@@ -0,0 +1,9 @@
+class MyTester
+  def foo
+    puts 'foo'
+  end
+
+  def bar
+    puts 'bar'
+  end
+end

data/spec/fixture_spec.rb

@@ -0,0 +1,74 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+include RepoFixture
+
+describe Fixture do
+  let(:fixture_class) { Fixture }
+  let(:fixture) { Fixture.new(TmpRepo.new) }
+
+  after(:each) do
+    fixture.unlink
+  end
+
+  describe '#copy_files' do
+    it 'copies files into the repo' do
+      path = File.dirname(__FILE__)
+
+      files_to_copy = Dir.glob(
+        File.join(File.expand_path('./fixture_files', path), '**')
+      )
+
+      expect(files_to_copy.size).to be > 0
+
+      fixture.copy_files(files_to_copy) do |file|
+        file[(path.length + 1)..-1]
+      end
+
+      copied_files = Dir.glob("#{fixture.working_dir}/**/**").select do |file|
+        File.file?(file)
+      end
+
+      expect(copied_files.size).to eq(files_to_copy.size)
+
+      files_to_copy.each do |file_to_copy|
+        expect(copied_files).to include(
+          File.join(fixture.working_dir, file_to_copy[(path.length + 1)..-1])
+        )
+      end
+    end
+  end
+
+  describe '#working_dir' do
+    it 'forwards messages to the underlying TmpRepo instance' do
+      expect(fixture).to respond_to(:working_dir)
+      expect(fixture.working_dir.to_s).to start_with(Dir.tmpdir)
+    end
+
+    it "doesn't forward methods that TmpRepo doesn't understand" do
+      expect(fixture).to_not respond_to(:foobar)
+      expect(lambda { fixture.foobar }).to raise_error(NoMethodError)
+    end
+  end
+
+  describe '#sh' do
+    it 'executes arbitrary commands in the context of the working directory' do
+      # Use include here instead of equality to avoid a test failure when
+      # running on systems that add a prefix to their tmp directory (i.e. MacOS).
+      expect(fixture.sh('pwd').strip).to include(fixture.working_dir.to_s)
+    end
+  end
+
+  describe '#export' do
+    it 'calls export on the given strategy class' do
+      output_file = './test.zip'
+      strategy = :zip
+
+      mock.proxy(ZipStrategy).export(output_file, fixture)
+      fixture.export(output_file, strategy)
+
+      File.unlink(output_file)
+    end
+  end
+end

data/spec/repo-fixture_spec.rb

@@ -0,0 +1,36 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+require 'pathname'
+
+include RepoFixture
+
+describe RepoFixture do
+  let(:fixture_class) { RepoFixture }
+
+  describe '#create' do
+    it 'yields a fixture object' do
+      fixture_class.create do |fixture|
+        expect(fixture).to be_a(Fixture)
+      end
+    end
+  end
+
+  describe '#load' do
+    it 'calls load on the appropriate strategy class' do
+      file = './test.zip'
+      mock(ZipStrategy).load(file)
+      fixture_class.load(file)
+    end
+  end
+
+  describe '#strategy_class_for' do
+    it 'returns the strategy class for the strategy name' do
+      expect(fixture_class.strategy_class_for(:zip)).to eq(ZipStrategy)
+    end
+
+    it "raises an error if the strategy doesn't exist" do
+      expect(lambda { fixture_class.strategy_class_for(:foo) }).to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+# encoding: UTF-8
+
+require 'rspec'
+require 'repo-fixture'
+require 'pry-nav'
+
+RSpec.configure do |config|
+  config.mock_with :rr
+end

data/spec/zip_strategy_spec.rb

@@ -0,0 +1,67 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+include RepoFixture
+
+describe ZipStrategy do
+  let(:fixture_class) { RepoFixture }
+
+  describe '#export' do
+    it 'creates a zip file containing all the files in the repo' do
+      fixture_file = './test.zip'
+
+      fixture = fixture_class.create do |fixture|
+        fixture.create_file('myfile.txt') { |f| f.write('foobarbaz') }
+        fixture.add_all
+        fixture.commit('Committing a foo file')
+      end
+
+      fixture.export(fixture_file, :zip)
+
+      Zip::File.open(fixture_file) do |zipfile|
+        zipfile.glob('myfile.txt').first.tap do |entry|
+          expect(entry.get_input_stream.read).to eq('foobarbaz')
+        end
+
+        expect(zipfile.glob('.git/COMMIT_EDITMSG').first).to_not be_nil
+      end
+
+      fixture.unlink
+      File.unlink(fixture_file)
+    end
+  end
+
+  context 'with a created fixture' do
+    before(:each) do
+      fixture = fixture_class.create do |fixture|
+        fixture.create_file('myfile.txt') { |f| f.write('foobarbaz') }
+        fixture.add_all
+        fixture.commit('Committing a foo file')
+      end
+
+      @fixture_file = Pathname('./test.zip')
+      fixture.export(@fixture_file, :zip)
+      expect(@fixture_file).to exist
+      fixture.unlink
+    end
+
+    after(:each) do
+      File.unlink(@fixture_file)
+    end
+
+    describe '#load' do
+      it 'should load a fixture using the given strategy' do
+        fixture = fixture_class.load(@fixture_file)
+
+        Dir.glob("#{fixture.working_dir}/**/**", File::FNM_DOTMATCH).tap do |files|
+          ['.git/COMMIT_EDITMSG', 'myfile.txt'].each do |expected_file|
+            expect(files).to include(File.join(fixture.working_dir, expected_file))
+          end
+        end
+
+        fixture.unlink
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: repo-fixture
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Cameron Dutro
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-09-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: tmp-repo
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.1
+- !ruby/object:Gem::Dependency
+  name: rubyzip
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+description: Build and package up git repositories as test fixtures.
+email:
+- camertron@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- History.txt
+- README.md
+- Rakefile
+- lib/repo-fixture.rb
+- lib/repo-fixture/fixture.rb
+- lib/repo-fixture/version.rb
+- lib/repo-fixture/zip_strategy.rb
+- repo-fixture.gemspec
+- spec/fixture_files/moar_test.coffee
+- spec/fixture_files/test.rb
+- spec/fixture_spec.rb
+- spec/repo-fixture_spec.rb
+- spec/spec_helper.rb
+- spec/zip_strategy_spec.rb
+homepage: http://github.com/camertron
+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: Build and package up git repositories as test fixtures.
+test_files: []