tty-file 0.7.0 → 0.7.1

data/spec/unit/binary_spec.rb

@@ -24,18 +24,36 @@ RSpec.describe TTY::File, '#binary?' do
     end
   end
 
-  it "identifies image as binary" do
+  it "identifies image file as binary" do
     file = tmp_path('blackhole.png')
 
     expect(TTY::File.binary?(file)).to eq(true)
   end
 
+  it "identifies an image file given as a pathname as binary" do
+    file = tmp_pathname('blackhole.png')
+
+    expect(TTY::File.binary?(file)).to eq(true)
+  end
+
+  it 'identifies image file provided by a Pathname instance as binary' do
+    file = tmp_pathname('blackhole.png')
+
+    expect(TTY::File.binary?(file)).to eq(true)
+  end
+
   it "indetifies text file as non-binary" do
     file = tmp_path('Gemfile')
 
     expect(TTY::File.binary?(file)).to eq(false)
   end
 
+  it 'identifies text file provided by a Pathname instance as non-binary' do
+    file = tmp_pathname('Gemfile')
+
+    expect(TTY::File.binary?(file)).to eq(false)
+  end
+
   it "indetifies a null-terminated string file as binary" do
     Tempfile.open('tty-file-binary-spec') do |file|
       file.write("Binary content.\0")

data/spec/unit/checksum_file_spec.rb

@@ -10,6 +10,15 @@ RSpec.describe TTY::File, '#checksum_file' do
     expect(checksum).to eq(expected)
   end
 
+  it "generates checksum for a Pathname instance" do
+    file = tmp_pathname('checksum/README.md')
+
+    checksum = TTY::File.checksum_file(file)
+    expected = '76ba1beb6c611fa32624ed253444138cdf23eb938a3812137f8a399c5b375bfe'
+
+    expect(checksum).to eq(expected)
+  end
+
   it "generates checksum for IO object" do
     io = StringIO.new("Some content\nThe end")
 

data/spec/unit/chmod_spec.rb

@@ -1,78 +1,92 @@
 # frozen_string_literal: true
 
-RSpec.describe TTY::File, '#chmod' do
-  context 'when octal permisssions' do
-    it "adds permissions to file - user executable",
-      unless: RSpec::Support::OS.windows? do
+RSpec.describe TTY::File, "#chmod" do
+  shared_context "changing file permissions" do
+    context 'when octal permisssions' do
+      it "adds permissions to file - user executable",
+        unless: RSpec::Support::OS.windows? do
 
-      file = tmp_path('script.sh')
-      mode = File.lstat(file).mode
-      expect(File.executable?(file)).to eq(false)
+        file = path_factory.call('script.sh')
+        mode = File.lstat(file).mode
+        expect(File.executable?(file)).to eq(false)
 
-      TTY::File.chmod(file, mode | TTY::File::U_X, verbose: false)
+        TTY::File.chmod(file, mode | TTY::File::U_X, verbose: false)
 
-      expect(File.lstat(file).mode).to eq(mode | TTY::File::U_X)
-    end
+        expect(File.lstat(file).mode).to eq(mode | TTY::File::U_X)
+      end
 
-    it "logs status when :verbose flag is true",
-      unless: RSpec::Support::OS.windows? do
+      it "logs status when :verbose flag is true",
+        unless: RSpec::Support::OS.windows? do
 
-      file = tmp_path('script.sh')
-      mode = File.lstat(file).mode
-      expect(File.executable?(file)).to eq(false)
+        file = path_factory.call('script.sh')
+        mode = File.lstat(file).mode
+        expect(File.executable?(file)).to eq(false)
 
-      expect {
-        TTY::File.chmod(file, mode | TTY::File::U_X)
-      }.to output(/chmod/).to_stdout_from_any_process
+        expect {
+          TTY::File.chmod(file, mode | TTY::File::U_X)
+        }.to output(/chmod/).to_stdout_from_any_process
 
-      expect(File.lstat(file).mode).to eq(mode | TTY::File::U_X)
-    end
+        expect(File.lstat(file).mode).to eq(mode | TTY::File::U_X)
+      end
 
-    it "doesn't change permission when :noop flag is true" do
-      file = tmp_path('script.sh')
-      mode = File.lstat(file).mode
-      expect(File.executable?(file)).to eq(false)
+      it "doesn't change permission when :noop flag is true" do
+        file = path_factory.call('script.sh')
+        mode = File.lstat(file).mode
+        expect(File.executable?(file)).to eq(false)
 
-      TTY::File.chmod(file, mode | TTY::File::U_X, verbose: false, noop: true)
+        TTY::File.chmod(file, mode | TTY::File::U_X, verbose: false, noop: true)
 
-      expect(File.lstat(file).mode).to eq(mode)
+        expect(File.lstat(file).mode).to eq(mode)
+      end
     end
-  end
 
-  context 'when human readable permissions' do
-    it "adds permisions to file - user executable",
-      unless: RSpec::Support::OS.windows? do
+    context 'when human readable permissions' do
+      it "adds permisions to file - user executable",
+        unless: RSpec::Support::OS.windows? do
 
-      file = tmp_path('script.sh')
-      mode = File.lstat(file).mode
-      expect(File.executable?(file)).to eq(false)
+        file = path_factory.call('script.sh')
+        mode = File.lstat(file).mode
+        expect(File.executable?(file)).to eq(false)
 
-      TTY::File.chmod(file, 'u+x', verbose: false)
+        TTY::File.chmod(file, 'u+x', verbose: false)
 
-      expect(File.lstat(file).mode).to eq(mode | TTY::File::U_X)
-    end
+        expect(File.lstat(file).mode).to eq(mode | TTY::File::U_X)
+      end
 
-    it "removes permission for user executable" do
-      file = tmp_path('script.sh')
-      mode = File.lstat(file).mode
-      expect(File.writable?(file)).to eq(true)
+      it "removes permission for user executable" do
+        file = path_factory.call('script.sh')
+        mode = File.lstat(file).mode
+        expect(File.writable?(file)).to eq(true)
 
-      TTY::File.chmod(file, 'u-w', verbose: false)
+        TTY::File.chmod(file, 'u-w', verbose: false)
 
-      expect(File.lstat(file).mode).to eq(mode ^ TTY::File::U_W)
-      expect(File.writable?(file)).to eq(false)
-    end
+        expect(File.lstat(file).mode).to eq(mode ^ TTY::File::U_W)
+        expect(File.writable?(file)).to eq(false)
+      end
 
-    it "adds multiple permissions separated by comma",
-      unless: RSpec::Support::OS.windows? do
+      it "adds multiple permissions separated by comma",
+        unless: RSpec::Support::OS.windows? do
 
-      file = tmp_path('script.sh')
-      mode = File.lstat(file).mode
-      expect(File.executable?(file)).to eq(false)
+        file = path_factory.call('script.sh')
+        mode = File.lstat(file).mode
+        expect(File.executable?(file)).to eq(false)
 
-      TTY::File.chmod(file, 'u+x,g+x', verbose: false)
+        TTY::File.chmod(file, 'u+x,g+x', verbose: false)
 
-      expect(File.lstat(file).mode).to eq(mode | TTY::File::U_X | TTY::File::G_X)
+        expect(File.lstat(file).mode).to eq(mode | TTY::File::U_X | TTY::File::G_X)
+      end
     end
   end
+
+  context "when passed a String instance for the file argument" do
+    let(:path_factory) { method(:tmp_path) }
+
+    include_context "changing file permissions"
+  end
+
+  context "when passed a Pathname instance for the file argument" do
+    let(:path_factory) { method(:tmp_pathname) }
+
+    include_context "changing file permissions"
+  end
 end

data/spec/unit/copy_directory_spec.rb

@@ -1,106 +1,120 @@
 # frozen_string_literal: true
 
-RSpec.describe TTY::File, '#copy_directory' do
-  it "copies directory of files recursively" do
-    app = tmp_path('cli_app')
-    apps = tmp_path('apps')
-
-    variables = OpenStruct.new
-    variables[:name] = 'tty'
-    variables[:foo] = 'Foo'
-    variables[:bar] = 'Bar'
-
-    TTY::File.copy_directory(app, apps, context: variables, verbose: false)
-
-    expect(Find.find(apps).to_a).to eq([
-      tmp_path('apps'),
-      tmp_path('apps/README'),
-      tmp_path('apps/command.rb'),
-      tmp_path('apps/commands'),
-      tmp_path('apps/commands/subcommand.rb'),
-      tmp_path('apps/excluded'),
-      tmp_path('apps/excluded/command.rb'),
-      tmp_path('apps/excluded/tty_cli.rb'),
-      tmp_path('apps/tty_cli.rb')
-    ])
-
-    expect(File.read(tmp_path('apps/command.rb'))).to eq("class FooCommand\nend\n")
-    expect(File.read(tmp_path('apps/excluded/command.rb'))).to eq("class BarCommand\nend\n")
+RSpec.describe TTY::File, "#copy_directory" do
+  shared_context "copies directory" do
+    it "copies directory of files recursively" do
+      app  = path_factory.call('cli_app')
+      apps = path_factory.call('apps')
+
+      variables = OpenStruct.new
+      variables[:name] = 'tty'
+      variables[:foo] = 'Foo'
+      variables[:bar] = 'Bar'
+
+      TTY::File.copy_directory(app, apps, context: variables, verbose: false)
+
+      expect(Find.find(apps.to_s).to_a).to eq([
+        tmp_path('apps'),
+        tmp_path('apps/README'),
+        tmp_path('apps/command.rb'),
+        tmp_path('apps/commands'),
+        tmp_path('apps/commands/subcommand.rb'),
+        tmp_path('apps/excluded'),
+        tmp_path('apps/excluded/command.rb'),
+        tmp_path('apps/excluded/tty_cli.rb'),
+        tmp_path('apps/tty_cli.rb')
+      ])
+
+      expect(File.read(tmp_path('apps/command.rb'))).to eq("class FooCommand\nend\n")
+      expect(File.read(tmp_path('apps/excluded/command.rb'))).to eq("class BarCommand\nend\n")
+    end
+
+    it "copies top level directory of files and evalutes templates" do
+      app  = path_factory.call('cli_app')
+      apps = path_factory.call('apps')
+
+      variables = OpenStruct.new
+      variables[:name] = 'tty'
+      variables[:foo] = 'Foo'
+      variables[:bar] = 'Bar'
+
+      TTY::File.copy_directory(app, apps, recursive: false,
+                                          context: variables,
+                                          verbose: false)
+
+      expect(Find.find(apps.to_s).to_a).to eq([
+        tmp_path('apps'),
+        tmp_path('apps/README'),
+        tmp_path('apps/command.rb'),
+        tmp_path('apps/tty_cli.rb')
+      ])
+    end
+
+    it "handles glob characters in the path" do
+      src  = path_factory.call("foo[1]")
+      dest = path_factory.call("foo1")
+      TTY::File.copy_directory(src, dest, verbose: false)
+
+      expect(Find.find(dest.to_s).to_a).to eq([
+        tmp_path('foo1'),
+        tmp_path('foo1/README.md')
+      ])
+    end
+
+    it "ignores excluded directories" do
+      src  = path_factory.call('cli_app')
+      dest = path_factory.call('ignored')
+
+      variables = OpenStruct.new
+      variables[:name] = 'tty'
+      variables[:foo] = 'Foo'
+      variables[:bar] = 'Bar'
+
+      TTY::File.copy_directory(src, dest, context: variables,
+                                          exclude: %r{excluded/},
+                                          verbose: false)
+
+      expect(Find.find(dest.to_s).to_a).to eq([
+        tmp_path('ignored'),
+        tmp_path('ignored/README'),
+        tmp_path('ignored/command.rb'),
+        tmp_path('ignored/commands'),
+        tmp_path('ignored/commands/subcommand.rb'),
+        tmp_path('ignored/tty_cli.rb')
+      ])
+    end
+
+    it "raises error when source directory doesn't exist" do
+      expect {
+        TTY::File.copy_directory('unknown')
+      }.to raise_error(ArgumentError, %r{File path "unknown" does not exist.})
+    end
+
+    it "logs status" do
+      app  = path_factory.call('cli_app')
+      apps = path_factory.call('apps')
+
+      variables = OpenStruct.new
+      variables[:name] = 'tty'
+      variables[:class_name] = 'TTY'
+
+      expect {
+        TTY::File.copy_directory(app, apps, context: variables, verbose: true)
+      }.to output(
+        %r{create(.*)apps/tty_cli.rb\n(.*)create(.*)apps/README\n(.*)create(.*)apps/command.rb\n}m
+      ).to_stdout_from_any_process
+    end
   end
 
-  it "copies top level directory of files and evalutes templates" do
-    app  = tmp_path('cli_app')
-    apps = tmp_path('apps')
-
-    variables = OpenStruct.new
-    variables[:name] = 'tty'
-    variables[:foo] = 'Foo'
-    variables[:bar] = 'Bar'
-
-    TTY::File.copy_directory(app, apps, recursive: false,
-                                        context: variables,
-                                        verbose: false)
-
-    expect(Find.find(apps).to_a).to eq([
-      tmp_path('apps'),
-      tmp_path('apps/README'),
-      tmp_path('apps/command.rb'),
-      tmp_path('apps/tty_cli.rb')
-    ])
-  end
-
-  it "handles glob characters in the path" do
-    src = tmp_path("foo[1]")
-    dest = tmp_path("foo1")
-    TTY::File.copy_directory(src, dest, verbose: false)
-
-    expect(Find.find(dest).to_a).to eq([
-      tmp_path('foo1'),
-      tmp_path('foo1/README.md')
-    ])
-  end
+  context "when passed String instances for the file arguments" do
+    let(:path_factory) { method(:tmp_path) }
 
-  it "ignores excluded directories" do
-    src = tmp_path('cli_app')
-    dest = tmp_path('ignored')
-
-    variables = OpenStruct.new
-    variables[:name] = 'tty'
-    variables[:foo] = 'Foo'
-    variables[:bar] = 'Bar'
-
-    TTY::File.copy_directory(src, dest, context: variables,
-                                        exclude: %r{excluded/},
-                                        verbose: false)
-
-    expect(Find.find(dest).to_a).to eq([
-      tmp_path('ignored'),
-      tmp_path('ignored/README'),
-      tmp_path('ignored/command.rb'),
-      tmp_path('ignored/commands'),
-      tmp_path('ignored/commands/subcommand.rb'),
-      tmp_path('ignored/tty_cli.rb')
-    ])
+    it_behaves_like "copies directory"
   end
 
-  it "raises error when source directory doesn't exist" do
-    expect {
-      TTY::File.copy_directory('unknown')
-    }.to raise_error(ArgumentError, %r{File path "unknown" does not exist.})
-  end
-
-  it "logs status" do
-    app  = tmp_path('cli_app')
-    apps = tmp_path('apps')
-
-    variables = OpenStruct.new
-    variables[:name] = 'tty'
-    variables[:class_name] = 'TTY'
+  context "when passed Pathname instances for the file arguments" do
+    let(:path_factory) { method(:tmp_pathname) }
 
-    expect {
-      TTY::File.copy_directory(app, apps, context: variables, verbose: true)
-    }.to output(
-      %r{create(.*)apps/tty_cli.rb\n(.*)create(.*)apps/README\n(.*)create(.*)apps/command.rb\n}m
-    ).to_stdout_from_any_process
+    it_behaves_like "copies directory"
   end
 end

data/spec/unit/copy_file_spec.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
+
 require 'ostruct'
 
-RSpec.describe TTY::File, '#copy_file' do
+RSpec.describe TTY::File, "#copy_file" do
   def exists_and_identical?(source, dest)
     dest_path = File.join(tmp_path, dest)
     expect(::File.exist?(dest_path)).to be(true)
@@ -10,148 +11,162 @@ RSpec.describe TTY::File, '#copy_file' do
     expect(::FileUtils).to be_identical(source_path, dest_path)
   end
 
-  it "copies file without destination" do
-    src = tmp_path('Gemfile')
+  shared_context 'copying files' do
+    it "copies file without destination" do
+      src = path_factory.call('Gemfile')
 
-    TTY::File.copy_file(src, verbose: false)
+      TTY::File.copy_file(src, verbose: false)
 
-    exists_and_identical?('Gemfile', 'Gemfile')
-  end
+      exists_and_identical?('Gemfile', 'Gemfile')
+    end
 
-  it "copies file to the destination" do
-    src  = tmp_path('Gemfile')
-    dest = tmp_path('app/Makefile')
+    it "copies file to the destination" do
+      src  = path_factory.call('Gemfile')
+      dest = path_factory.call('app/Makefile')
 
-    TTY::File.copy_file(src, dest, verbose: false)
+      TTY::File.copy_file(src, dest, verbose: false)
 
-    exists_and_identical?('Gemfile', 'app/Makefile')
-  end
+      exists_and_identical?('Gemfile', 'app/Makefile')
+    end
 
-  it "copies file to existing destination" do
-    src  = tmp_path('Gemfile')
-    dest = tmp_path('app/Gemfile')
+    it "copies file to existing destination" do
+      src  = path_factory.call('Gemfile')
+      dest = path_factory.call('app/Gemfile')
 
-    TTY::File.copy_file(src, dest, verbose: false)
+      TTY::File.copy_file(src, dest, verbose: false)
 
-    exists_and_identical?('Gemfile', 'app/Gemfile')
-  end
+      exists_and_identical?('Gemfile', 'app/Gemfile')
+    end
 
-  it "copies file with block content" do
-    src  = tmp_path('Gemfile')
-    dest = tmp_path('app/Gemfile')
+    it "copies file with block content" do
+      src  = path_factory.call('Gemfile')
+      dest = path_factory.call('app/Gemfile')
 
-    TTY::File.copy_file(src, dest, verbose: false) do |content|
-      "https://rubygems.org\n" + content
+      TTY::File.copy_file(src, dest, verbose: false) do |content|
+        "https://rubygems.org\n" + content
+      end
+      expect(File.read(dest)).to eq("https://rubygems.org\ngem 'nokogiri'\ngem 'rails', '5.0.0'\ngem 'rack', '>=1.0'\n")
     end
-    expect(File.read(dest)).to eq("https://rubygems.org\ngem 'nokogiri'\ngem 'rails', '5.0.0'\ngem 'rack', '>=1.0'\n")
-  end
 
-  it "copies file and preservs metadata" do
-    src  = tmp_path('Gemfile')
-    dest = tmp_path('app/Gemfile')
+    it "copies file and preservs metadata" do
+      src  = path_factory.call('Gemfile')
+      dest = path_factory.call('app/Gemfile')
 
-    expect {
-      TTY::File.copy_file(src, dest, verbose: false, preserve: true)
-    }.to output('').to_stdout_from_any_process
+      expect {
+        TTY::File.copy_file(src, dest, verbose: false, preserve: true)
+      }.to output('').to_stdout_from_any_process
 
-    expect(File.stat(src)).to eq(File.stat(dest))
-  end
+      expect(File.stat(src)).to eq(File.stat(dest))
+    end
 
-  it "doesn't copy file if :noop is true" do
-    src  = tmp_path('Gemfile')
-    dest = tmp_path('app/Gemfile')
+    it "doesn't copy file if :noop is true" do
+      src  = path_factory.call('Gemfile')
+      dest = path_factory.call('app/Gemfile')
 
-    TTY::File.copy_file(src, dest, verbose: false, noop: true)
+      TTY::File.copy_file(src, dest, verbose: false, noop: true)
 
-    expect(File.exist?(dest)).to eq(false)
-  end
+      expect(File.exist?(dest)).to eq(false)
+    end
 
-  it "logs status" do
-    src  = tmp_path('Gemfile')
-    dest = tmp_path('app/Gemfile')
+    it "logs status" do
+      src  = path_factory.call('Gemfile')
+      dest = path_factory.call('app/Gemfile')
 
-    expect {
-      TTY::File.copy_file(src, dest)
-    }.to output(/\e\[32mcreate\e\[0m.*Gemfile/).to_stdout_from_any_process
-  end
+      expect {
+        TTY::File.copy_file(src, dest)
+      }.to output(/\e\[32mcreate\e\[0m.*Gemfile/).to_stdout_from_any_process
+    end
 
-  it "logs status without color" do
-    src  = tmp_path('Gemfile')
-    dest = tmp_path('app/Gemfile')
+    it "logs status without color" do
+      src  = path_factory.call('Gemfile')
+      dest = path_factory.call('app/Gemfile')
 
-    expect {
-      TTY::File.copy_file(src, dest, color: false)
-    }.to output(/\s+create.*Gemfile/).to_stdout_from_any_process
-  end
+      expect {
+        TTY::File.copy_file(src, dest, color: false)
+      }.to output(/\s+create.*Gemfile/).to_stdout_from_any_process
+    end
 
-  it "removes template .erb extension" do
-    src = tmp_path('templates/application.html.erb')
+    it "removes template .erb extension" do
+      src = path_factory.call('templates/application.html.erb')
 
-    TTY::File.copy_file(src, verbose: false)
+      TTY::File.copy_file(src, verbose: false)
 
-    exists_and_identical?('templates/application.html.erb',
-                          'templates/application.html')
-  end
+      exists_and_identical?('templates/application.html.erb',
+                            'templates/application.html')
+    end
 
-  it "converts filename based on context" do
-    src = tmp_path('templates/%file_name%.rb')
-    dest = tmp_path('app/%file_name%.rb')
+    it "converts filename based on context" do
+      src  = path_factory.call('templates/%file_name%.rb')
+      dest = path_factory.call('app/%file_name%.rb')
 
-    variables = OpenStruct.new
-    variables[:foo] = 'bar'
-    variables[:file_name] = 'expected'
+      variables = OpenStruct.new
+      variables[:foo] = 'bar'
+      variables[:file_name] = 'expected'
 
-    TTY::File.copy_file(src, dest, context: variables, verbose: false)
+      TTY::File.copy_file(src, dest, context: variables, verbose: false)
 
-    expected = tmp_path('app/expected.rb')
-    expect(File.read(expected)).to eq("bar\n")
-  end
+      expected = tmp_path('app/expected.rb')
+      expect(File.read(expected)).to eq("bar\n")
+    end
 
-  it "converts filename based on class context" do
-    src  = tmp_path('templates/%file_name%.rb')
-    dest = tmp_path('templates/expected.rb')
+    it "converts filename based on class context" do
+      src  = path_factory.call('templates/%file_name%.rb')
+      dest = path_factory.call('templates/expected.rb')
 
-    stub_const('TestCase', Class.new {
-      def foo
-        'bar'
-      end
+      stub_const('TestCase', Class.new {
+        def foo
+          'bar'
+        end
 
-      def file_name
-        'expected'
-      end
-    })
-    TestCase.send(:include, TTY::File)
+        def file_name
+          'expected'
+        end
+      })
+      TestCase.send(:include, TTY::File)
 
-    TestCase.new.send(:copy_file, src, verbose: false)
+      TestCase.new.send(:copy_file, src, verbose: false)
 
-    expect(File.read(dest)).to eq("bar\n")
-  end
+      expect(File.read(dest)).to eq("bar\n")
+    end
 
-  it "copies file with custom class context" do
-    src  = tmp_path('templates/unit_test.rb')
-    dest = tmp_path('test/unit_test.rb')
+    it "copies file with custom class context" do
+      src  = path_factory.call('templates/unit_test.rb')
+      dest = path_factory.call('test/unit_test.rb')
 
-    stub_const('TestCase', Class.new {
-      def self.class_name
-        'Example'
-      end
-    })
-    TestCase.extend(TTY::File)
+      stub_const('TestCase', Class.new {
+        def self.class_name
+          'Example'
+        end
+      })
+      TestCase.extend(TTY::File)
+
+      TestCase.send(:copy_file, src, dest, verbose: false)
+
+      expect(File.read(dest)).to eq("class ExampleTest; end\n")
+    end
 
-    TestCase.send(:copy_file, src, dest, verbose: false)
+    it "copies template with custom context binding" do
+      src  = path_factory.call('templates/unit_test.rb')
+      dest = path_factory.call('test/unit_test.rb')
 
-    expect(File.read(dest)).to eq("class ExampleTest; end\n")
+      variables = OpenStruct.new
+      variables[:class_name] = 'Example'
+
+      TTY::File.copy_file(src, dest, context: variables, verbose: false)
+
+      expect(File.read(dest)).to eq("class ExampleTest; end\n")
+    end
   end
 
-  it "copies template with custom context binding" do
-    src  = tmp_path('templates/unit_test.rb')
-    dest = tmp_path('test/unit_test.rb')
+  context "when passed String instances for the file arguments" do
+    let(:path_factory) { method(:tmp_path) }
 
-    variables = OpenStruct.new
-    variables[:class_name] = 'Example'
+    include_context "copying files"
+  end
 
-    TTY::File.copy_file(src, dest, context: variables, verbose: false)
+  context "when passed Pathname instances for the file arguments" do
+    let(:path_factory) { method(:tmp_pathname) }
 
-    expect(File.read(dest)).to eq("class ExampleTest; end\n")
+    include_context "copying files"
   end
 end