percy-capybara 3.2.0 → 4.0.0.pre.beta1

data/spec/lib/percy/capybara/loaders/sprockets_loader_spec.rb

@@ -1,119 +0,0 @@
-require 'sprockets'
-
-class SimpleRackApp
-  def self.call(_env)
-    [200, {}, 'Hello World']
-  end
-end
-
-RSpec.describe Percy::Capybara::Loaders::SprocketsLoader do
-  let(:test_data_path) do
-    File.expand_path('../../client/test_data', __FILE__)
-  end
-  let(:rails_public_test_data_path) do
-    File.expand_path('../../client/rails_public_test_data', __FILE__)
-  end
-  let(:loader) do
-    Percy::Capybara::Loaders::SprocketsLoader.new(
-      page: page,
-      sprockets_environment: environment,
-      sprockets_options: sprockets_options,
-    )
-  end
-  let(:environment) do
-    environment = Sprockets::Environment.new(test_data_path)
-    environment.append_path '.'
-    environment
-  end
-  let(:digest_enabled) { false }
-  let(:sprockets_options) do
-    options = double('options')
-    # Set specific files we want to compile. In normal use, this would be all asset files.
-    precompile_list = [/(?:\/|\\|\A)(base|digested)\.(css|js)$|\.map|\.png/]
-    allow(options).to receive(:precompile).and_return(precompile_list)
-    allow(options).to receive(:digest).and_return(digest_enabled)
-    options
-  end
-
-  describe '#snapshot_resources' do
-    context 'Rack::Test', type: :feature do
-      before(:each) { Capybara.app = SimpleRackApp }
-
-      it 'returns the root HTML resource' do
-        visit '/'
-        resources = loader.snapshot_resources
-        expect(resources.map(&:resource_url)).to eq(['/'])
-        expect(resources.first.is_root).to eq(true)
-        expect(resources.first.content).to include('Hello World')
-      end
-    end
-    context 'Capybara::Poltergeist', type: :feature, js: true do
-      it 'returns the root HTML resource' do
-        visit '/'
-        resources = loader.snapshot_resources
-        expect(resources.map(&:resource_url)).to eq(['/'])
-        expect(resources.first.is_root).to eq(true)
-        expect(resources.first.content).to include('Hello World!</body></html>')
-      end
-    end
-  end
-  describe '#build_resources', type: :feature do
-    it 'returns "build resources" from filtered sprockets paths' do
-      resources = loader.build_resources
-      expected_resources = [
-        '/assets/css/base.css',
-        '/assets/css/digested.css',
-        '/assets/images/bg-relative-to-root.png',
-        '/assets/images/bg-relative.png',
-        '/assets/images/bg-stacked.png',
-        '/assets/images/img-relative-to-root.png',
-        '/assets/images/img-relative.png',
-        # '/assets/images/large-file-skipped.png',  # Note: intentionally missing.
-        '/assets/images/srcset-base.png',
-        '/assets/images/srcset-first.png',
-        '/assets/images/srcset-second.png',
-        '/assets/js/base.js',
-      ]
-      expect(resources.map(&:resource_url)).to eq(expected_resources)
-      expect(resources.first.content).to include('.colored-by-base')
-    end
-    context 'Rails app' do
-      def setup_rails_double
-        # Pretend like we're in a Rails app right now, all we care about is Rails.public_path.
-        rails_double = double('Rails')
-        # Pretend like the entire test_data directory is the public/ folder.
-        expect(rails_double).to receive(:application).and_return(nil)
-        expect(rails_double).to receive(:public_path).and_return(rails_public_test_data_path)
-        expect(loader).to receive(:_rails).at_least(:once).and_return(rails_double)
-      end
-      it 'includes files from the public folder (non-asset-pipeline)' do
-        setup_rails_double
-        resources = loader.build_resources
-        # Weak test that more things are in this list, because it merges asset pipeline with public.
-        expect(resources.length).to be > 5
-
-        resource_urls = resources.map(&:resource_url)
-        expect(resource_urls).to include('/assets/images/bg-relative.png') # From asset pipeline.
-        expect(resource_urls).to include('/percy-from-public.svg') # Public merged into root.
-        expect(resource_urls).to include('/symlink_to_images/test.png') # Symlink in public dir.
-        expect(resource_urls).to_not include('/large-file-skipped.png') # Public merged into root.
-      end
-      context 'digest enabled' do
-        let(:digest_enabled) { true }
-
-        it 'only includes pre-compiled, digested files once' do
-          # This makes sure that we correctly merge already-compiled files in the assets directory
-          # with ones from the asset pipeline. This means that Rails users who have
-          # `config.assets.digest = true` set can safely run "rake assets:precompile" before tests.
-          setup_rails_double
-          resources = loader.build_resources
-          expected_digest_url = \
-            '/assets/css/digested-f3420c6aee71c137a3ca39727052811bae84b2f37' \
-            'd898f4db242e20656a1579e.css'
-          digested_resources = resources.select { |r| r.resource_url == expected_digest_url }
-          expect(digested_resources.length).to eq(1)
-        end
-      end
-    end
-  end
-end

data/spec/lib/percy/capybara_spec.rb

@@ -1,101 +0,0 @@
-RSpec.describe Percy::Capybara do
-  before(:each) do
-    Percy::Capybara.reset!
-    @original_env = ENV['TRAVIS_BUILD_ID']
-    ENV['TRAVIS_BUILD_ID'] = nil
-  end
-  after(:each) do
-    ENV['TRAVIS_BUILD_ID'] = @original_env
-    ENV.delete('PERCY_ENABLE')
-  end
-
-  describe '#capybara_client' do
-    it 'returns the current client or creates a new one' do
-      capybara_client = Percy::Capybara.capybara_client
-      expect(capybara_client).to be
-      # Verify that it memoizes the current object by calling it again:
-      expect(Percy::Capybara.capybara_client).to eq(capybara_client)
-    end
-  end
-  describe '#snapshot' do
-    it 'passes all arguments through to the current capybara_client' do
-      mock_page = double('page')
-      capybara_client = Percy::Capybara.capybara_client
-      expect(capybara_client).to receive(:snapshot).with(mock_page, {}).once
-      Percy::Capybara.snapshot(mock_page)
-      expect(capybara_client).to receive(:snapshot).with(mock_page, name: '/foo.html (modal)').once
-      Percy::Capybara.snapshot(mock_page, name: '/foo.html (modal)')
-    end
-    it 'silently skips if disabled' do
-      ENV['PERCY_ENABLE'] = '0'
-      mock_page = double('page')
-      Percy::Capybara.snapshot(mock_page)
-    end
-  end
-  describe '#initialize_build' do
-    it 'delegates to Percy::Capybara::Client' do
-      capybara_client = Percy::Capybara.capybara_client
-      expect(capybara_client).to receive(:initialize_build).once
-      Percy::Capybara.initialize_build
-    end
-  end
-  describe '#finalize_build' do
-    it 'returns silently if no build is initialized' do
-      expect { Percy::Capybara.finalize_build }.to_not raise_error
-    end
-    it 'delegates to Percy::Capybara::Client' do
-      capybara_client = Percy::Capybara.capybara_client
-      expect(capybara_client).to receive(:enabled?).and_return(true)
-      build_data = {'data' => {'id' => 123}}
-      expect(capybara_client.client).to receive(:create_build).and_return(build_data).once
-      Percy::Capybara.initialize_build
-      expect(capybara_client).to receive(:finalize_current_build).once
-      Percy::Capybara.finalize_build
-    end
-    it 'silently skips if disabled' do
-      ENV['PERCY_ENABLE'] = '0'
-      capybara_client = Percy::Capybara.capybara_client
-      expect(capybara_client.client).to_not receive(:create_build)
-      Percy::Capybara.initialize_build
-      expect(capybara_client).to_not receive(:finalize_current_build)
-      Percy::Capybara.finalize_build
-    end
-  end
-  describe '#reset!' do
-    it 'clears the current capybara_client' do
-      capybara_client = Percy::Capybara.capybara_client
-      Percy::Capybara.reset!
-      expect(Percy::Capybara.capybara_client).to_not eq(capybara_client)
-    end
-  end
-  describe '#disable!' do
-    it 'sets the current capybara_client to disabled' do
-      capybara_client = Percy::Capybara::Client.new(enabled: true)
-      expect(Percy::Capybara).to receive(:capybara_client)
-        .and_return(capybara_client).exactly(3).times
-      expect(Percy::Capybara.capybara_client.enabled?).to eq(true)
-      Percy::Capybara.disable!
-      expect(Percy::Capybara.capybara_client.enabled?).to eq(false)
-    end
-  end
-  describe '#use_loader' do
-    class DummyLoader < Percy::Capybara::Loaders::NativeLoader; end
-
-    it 'sets the current capybara client\'s loader' do
-      expect(Percy::Capybara.capybara_client.loader).to_not be
-      Percy::Capybara.reset!
-
-      Percy::Capybara.use_loader(DummyLoader)
-      expect(Percy::Capybara.capybara_client.loader).to be
-    end
-
-    it 'sets the current capybara client\'s loader options' do
-      expect(Percy::Capybara.capybara_client.loader_options).to eq({})
-      Percy::Capybara.reset!
-
-      Percy::Capybara.use_loader(DummyLoader, test_option: 3)
-      expect(Percy::Capybara.capybara_client.loader_options).to be
-      expect(Percy::Capybara.capybara_client.loader_options[:test_option]).to eq(3)
-    end
-  end
-end

data/spec/support/test_helpers.rb

@@ -1,60 +0,0 @@
-require 'socket'
-require 'timeout'
-require 'sprockets'
-
-module TestHelpers
-  class ServerDown < RuntimeError; end
-
-  def random_open_port
-    # Using a port of "0" relies on the system to pick an open port.
-    server = TCPServer.new('127.0.0.1', 0)
-    port = server.addr[1]
-    server.close
-    port
-  end
-
-  def verify_server_up(host)
-    http = HTTPClient.new
-    4.times do
-      begin
-        http.get(host)
-        return true
-      rescue Errno::ECONNREFUSED
-        sleep 0.5
-      end
-    end
-    raise ServerDown, "Server failed to start: #{host}"
-  end
-
-  def find_resource(resources, regex)
-    begin
-      resources.select { |resource| resource.resource_url.match(regex) }.fetch(0)
-    rescue IndexError
-      raise "Missing expected image with resource_url that matches: #{regex}"
-    end
-  end
-
-  def setup_sprockets(capybara_client)
-    root = File.expand_path('../../lib/percy/capybara/client/test_data', __FILE__)
-    environment = Sprockets::Environment.new(root)
-    environment.append_path '.'
-
-    sprockets_options = double('sprockets_options')
-    allow(sprockets_options).to receive(:precompile).and_return([/(?:\/|\\|\A)base\.(css|js)$/])
-    allow(sprockets_options).to receive(:digest).and_return(false)
-
-    capybara_client.sprockets_environment = environment
-    capybara_client.sprockets_options = sprockets_options
-  end
-
-  # Set the environment variables required by Percy::Client
-  def set_required_env_variables
-    ENV['PERCY_TOKEN'] = 'aa'
-  end
-
-  # Clear the environment variables required by Percy::Client
-  def clear_percy_env_variables
-    ENV.delete('PERCY_TOKEN')
-    ENV.delete('PERCY_ENABLE')
-  end
-end