netzke-testing 0.9.1 → 0.10.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b2f147065edf1276d30dfba903bc05f54dbf0720
-  data.tar.gz: 65575135cbe59ceb6315fd05dee8e49f6bf5b63d
+  metadata.gz: a398a89114051cb8e7bdde6ee2745c8579504010
+  data.tar.gz: 16e5861d805b4857cfa3bba04a0812816cefb830
 SHA512:
-  metadata.gz: 938b6591d4291148e65d4d746483116345f793b6b7f7749d9fd271ccd7a997270f71e8b7738a96b03d981a6b17ba0fdbe3731d8dec1d6abed6ea4167529f4366
-  data.tar.gz: dec776f456dd4a33d00ad9989dec8b6579cefc6b5a818f787efb8e0be68ebc359d225aa3594c1365ebf6dcc47bf050354bc990e6e50fb309f330cb287b83ca0e
+  metadata.gz: df63c42359d22684ed007539a5c24faa0e4722dc4f7494199c760bc0ffb748e4e2dc1fe4d75cbe7f8c406648218ef1cfe9583e744241055db4af76264dfba081
+  data.tar.gz: 909c16f872eb7862b59ded9bb166487136b77d92a1858df38a47a9289a6834e628b77febf4884f0c661a709173644f7c318ee84e187846968f8b41b0d0590c6c

data/.gitignore

@@ -12,6 +12,5 @@ lib/bundler/man
 pkg
 rdoc
 spec/reports
-test/tmp
-test/version_tmp
+spec/rails_app/public/extjs
 tmp

data/Gemfile

@@ -3,8 +3,8 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in netzke-testing.gemspec
 gemspec
 
-gem 'netzke-core', path: '../netzke-core'
-
 group :test do
   gem 'capybara'
+  gem 'selenium-webdriver'
+  gem 'netzke-core', '0.10.0.rc1'
 end

data/README.md

@@ -24,8 +24,8 @@ the height by providing the `height` parameter in the URL:
 
 ## Testing components with Mocha and Expect.js
 
-Place the Mocha specs (written in Coffeescript) for your components inside `spec/javascripts` folder. An example spec
-may look like this (in `spec/javascripts/user_grid.js.coffee`):
+Place the Mocha specs (written in Coffeescript) for your components inside `spec/features/javascripts` folder. An
+example spec may look like this (in `spec/features/javascripts/user_grid.js.coffee`):
 
     describe 'UserGrid', ->
       it 'shows proper title', ->
@@ -41,8 +41,8 @@ Specs can be structured into directories. For example, let's say we have a names
     class Admin::UserGrid < Netzke::Basepack::Grid
     end
 
-It makes sense to put the corresponding specs in `spec/javascripts/admin/user_grid.js.coffee`. In this case, the URL
-to run the Mocha specs will be:
+It makes sense to put the corresponding specs in `spec/features/javascripts/admin/user_grid.js.coffee`. In this case,
+   the URL to run the Mocha specs will be:
 
     http://localhost:3000/netzke/components/UserGrid?spec=admin/user_grid
 
@@ -67,13 +67,13 @@ In order to enable these helpers, add the following line somewhere in your `RSpe
 Keep in mind the following:
 
   * the current set of helpers is in flux, and may be drastically changed sooner than you may expect
-  * the helpers directly pollute the `window` namespace; if you decide you're better off without provided helpers,
-  specify 'no-helpers=true' as an extra URL parameter
+  * the helpers directly pollute the global (`window`) namespace; if you decide you're better off without provided
+  helpers, specify 'no-helpers=true' as an extra URL parameter
 
 See the [source
 code](https://github.com/netzke/netzke-testing/tree/master/app/assets/javascripts/netzke/testing/helpers) for currently
 implemented helpers (TODO: document them). Also, refer to other Netzke gems source code (like netzke-core and
-    netzke-basepack) to see examples using the helpers.
+netzke-basepack) to see examples using the helpers.
 
 ## Testing with selenium webdriver
 
@@ -81,10 +81,11 @@ Generate the `netzke_mocha_spec.rb` file that will automatically run the specs t
 
     rails g netzke_testing
 
-This spec will pick up all the `*_spec.js.coffee` files from `spec/javascripts` folder and generate an `it` clause for
-each of them. Let's say we want to create the spec for UserGrid. For this we name the spec file
-`spec/javascripts/user_grid_spec.js.coffee`. And the other way around: when `netzke_mocha_spec.rb` finds a file called
-`spec/javascripts/order_grid_spec.js.coffee`, it'll assume existance of `OrderGrid` component that should be tested.
+This spec will pick up all the `*_spec.js.coffee` files from `spec/features/javascripts` folder and generate an `it`
+clause for each of them. Let's say we want to create the spec for UserGrid. For this we name the spec file
+`spec/features/javascripts/user_grid_spec.js.coffee`. And the other way around: when `netzke_mocha_spec.rb` finds a file
+called `spec/features/javascripts/order_grid_spec.js.coffee`, it'll assume existance of `OrderGrid` component that
+should be tested.
 
 ## Mixing client- and server-side testing code
 
@@ -109,7 +110,7 @@ You can explicitely specify a component to run the spec on (in order to override
     run_mocha_spec 'grid_with_destructive_button', component: 'UserGrid'
 
 ---
-Copyright (c) 2008-2013 [Max Gorin](https://twitter.com/uptomax), released under the MIT license (see LICENSE).
+Copyright (c) 2008-2014 [Max Gorin](https://twitter.com/uptomax), released under the MIT license (see LICENSE).
 
 **Note** that Ext JS is licensed [differently](http://www.sencha.com/products/extjs/license/), and you may need to
 purchase a commercial license in order to use it in your projects!

data/Rakefile

@@ -1 +1,8 @@
 require "bundler/gem_tasks"
+
+desc "Run all tests"
+task :test do
+  system("bundle exec rspec spec") || abort
+end
+
+task default: :test

data/app/assets/javascripts/netzke/testing/helpers/expectations.js.coffee

@@ -1,6 +1,7 @@
 Ext.apply window,
-  expectToSee: (el) ->
-    expect(Ext.isObject(el) || Ext.isElement(el)).to.be.ok()
+  expectToSee: (cmp) ->
+    throw cmp + " not found" if Ext.isString(cmp)
+    expect(Ext.isObject(cmp) || Ext.isElement(cmp)).to.be.ok()
 
   expectToNotSee: (el) ->
     expect(Ext.isString(el)).to.be.ok()

data/app/assets/javascripts/netzke/testing/helpers/queries.js.coffee

@@ -11,7 +11,9 @@ Ext.apply window,
     Ext.DomQuery.select("div.x-panel-body:contains(" + text + ")")[0] || 'panel with content ' + text
 
   button: (text) ->
-    Ext.ComponentQuery.query("button{isVisible(true)}[text='"+text+"']")[0] || "button " + text
+    button = Ext.ComponentQuery.query("button{isVisible(true)}[text='"+text+"']")[0]
+    button ||= Ext.ComponentQuery.query("button{isVisible(true)}[tooltip='"+text+"']")[0]
+    button || "button " + text
 
   tool: (type) ->
     Ext.ComponentQuery.query("tool{isVisible(true)}[type='"+type+"']")[0] || 'tool ' + type
@@ -82,6 +84,18 @@ Ext.apply window,
         return
     res
 
+  eastRegion: ->
+    Ext.ComponentQuery.query("[region=east]")[0]
+
+  westRegion: ->
+    Ext.ComponentQuery.query("[region=west]")[0]
+
+  southRegion: ->
+    Ext.ComponentQuery.query("[region=south]")[0]
+
+  northRegion: ->
+    Ext.ComponentQuery.query("[region=north]")[0]
+
   _componentLike:(type,attr,value)->
     Ext.ComponentQuery.query(type+'['+attr+'='+value+']')[0] || type + " with " + attr + " '" + value + "'"
 # alias

data/app/controllers/netzke/testing_controller.rb

@@ -1,6 +1,8 @@
 require 'coffee-script'
 
 class Netzke::TestingController < ApplicationController
+  before_filter :set_locale
+
   def components
     component_name = params[:class].gsub("::", "_").underscore
     render :inline => "<%= netzke :#{component_name}, :class_name => '#{params[:class]}', :height => #{params[:height] || 400} %>",
@@ -14,13 +16,18 @@ class Netzke::TestingController < ApplicationController
 
   private
 
+  def set_locale
+    # if params[:locale] is nil then I18n.default_locale will be used
+    I18n.locale = params[:locale]
+  end
+
   def spec_file(name)
     spec_root = Pathname.new(Netzke::Testing.spec_root || Rails.root)
 
-    path = spec_root.join "spec/javascripts/#{name}_spec.js.coffee"
+    path = spec_root.join "spec/features/javascripts/#{name}_spec.js.coffee"
 
     if !File.exists?(File.expand_path(path, __FILE__))
-      path = spec_root.join "spec/javascripts/#{name}.js.coffee"
+      path = spec_root.join "spec/features/javascripts/#{name}.js.coffee"
     end
 
     File.read(File.expand_path(path, __FILE__))

data/app/views/layouts/netzke/testing.html.erb

@@ -6,23 +6,28 @@
   <%= load_netzke %>
 
   <% if params[:spec] %>
-    <%= javascript_include_tag "/assets/javascripts/expect/expect.js" %>
-    <%= javascript_include_tag "/assets/javascripts/mocha/mocha.js" %>
-    <%= stylesheet_link_tag "/assets/stylesheets/mocha/mocha.css" %>
+    <%= javascript_include_tag "/assets/netzke/testing/expect/expect.js" %>
+    <%= javascript_include_tag "/assets/netzke/testing/mocha/mocha.js" %>
+    <%= stylesheet_link_tag "/assets/netzke/testing/mocha/mocha.css" %>
     <script>
       mocha.setup('bdd');
-      mocha.setup({ignoreLeaks: true, slow: 500});
+      mocha.setup({ignoreLeaks: true, slow: 500, timeout: 5000});
       Ext.onReady(function(){
         Netzke.mochaRunner = mocha.run(function(){Netzke.mochaDone = true;});
       });
     </script>
-    <% if params["no-helpers"].nil? %>
+    <% if !params["no-helpers"] %>
       <%= javascript_include_tag "/assets/netzke/testing/helpers/actions" %>
       <%= javascript_include_tag "/assets/netzke/testing/helpers/queries" %>
       <%= javascript_include_tag "/assets/netzke/testing/helpers/expectations" %>
       <%= javascript_include_tag "/assets/netzke/testing/helpers/grid" %>
       <%= javascript_include_tag "/assets/netzke/testing/helpers/form" %>
     <% end %>
+
+    <% for path in Netzke::Testing.custom_js %>
+      <%= javascript_include_tag path %>
+    <% end %>
+
     <%= javascript_include_tag "/netzke/specs/#{params[:spec]}" %>
   <% end %>
 

data/lib/netzke/testing/helpers.rb

@@ -1,8 +1,8 @@
 module Netzke::Testing::Helpers
   def run_mocha_spec(path, options = {})
-    component = options[:component] || path.camelcase
+    @component = options[:component] || path.camelcase
     locale = options[:locale]
-    url = netzke_components_path(class: component, spec: path)
+    url = netzke_components_path(class: @component, spec: path)
     url << "&locale=#{locale}" if locale
 
     visit url
@@ -18,8 +18,8 @@ module Netzke::Testing::Helpers
     loop do
       page.execute_script("return Netzke.mochaDone;") ? break : sleep(0.1)
 
-      # no specs are supposed to run longer than 10 seconds
-      raise "Timeout running JavaScript specs for #{component}" if Time.now > start + 10.seconds
+      # no specs are supposed to run longer than 100 seconds
+      raise "Timeout running JavaScript specs for #{@component}" if Time.now > start + 100.seconds
     end
 
   rescue Selenium::WebDriver::Error::JavascriptError => e
@@ -31,17 +31,21 @@ module Netzke::Testing::Helpers
   end
 
   def assert_mocha_results
-    success = page.execute_script(<<-JS)
-      var stats = Netzke.mochaRunner.stats;
-      return stats.failures == 0 && stats.tests !=0
+    result = page.execute_script(<<-JS)
+      var runner = Netzke.mochaRunner;
+      return {
+        test: runner.test.title,
+        success: runner.stats.failures == 0 && runner.stats.tests !=0,
+        error: runner.test.err && runner.test.err.toString()
+      }
     JS
 
-    if !success
+    if !result["success"]
       # give some time for visual examination of the problem
       # (TODO: make configurable)
       sleep 5
 
-      raise "JS expectations failed"
+      raise "Test failed: #{result["test"]}\n#{result["error"]}"
     end
   end
 end

data/lib/netzke/testing/version.rb

@@ -1,5 +1,5 @@
 module Netzke
   module Testing
-    VERSION = "0.9.1"
+    VERSION = "0.10.0.rc1"
   end
 end

data/lib/netzke/testing.rb

@@ -8,8 +8,13 @@ end
 
 module Netzke
   module Testing
+    # Path to the root of your JS specs (which are part of integration tests)
     mattr_accessor :spec_root
 
+    # JS paths that should be included in the testing template
+    mattr_accessor :custom_js
+    @@custom_js = []
+
     def self.rspec_init(rspec_config)
       @@spec_root = Pathname.new(caller.first).join("../..")
       rspec_config.include(Netzke::Testing::Helpers)

data/netzke-testing.gemspec

@@ -20,7 +20,9 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "rails"
+  spec.add_development_dependency "rails", "~> 3.2.0"
+  spec.add_development_dependency "sqlite3"
   spec.add_development_dependency "rspec-rails"
   spec.add_development_dependency "coffee-script"
+  spec.add_development_dependency 'netzke-core', '0.10.0.rc1'
 end

data/spec/features/foo_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+feature "Foo", js: true do
+  it 'runs JS specs' do
+    run_mocha_spec "foo"
+  end
+end

data/spec/features/javascripts/foo.js.coffee

@@ -0,0 +1,6 @@
+describe 'Foo', ->
+  afterEach (done) ->
+    done()
+
+  it 'shows as a panel with title "Test component"', ->
+    expectToSee header "Test component"

data/spec/rails_app/.gitignore

@@ -0,0 +1,15 @@
+# See http://help.github.com/ignore-files/ for more about ignoring files.
+#
+# If you find yourself ignoring temporary files generated by your text editor
+# or operating system, you probably want to add a global ignore instead:
+#   git config --global core.excludesfile ~/.gitignore_global
+
+# Ignore bundler config
+/.bundle
+
+# Ignore the default SQLite database.
+/db/*.sqlite3
+
+# Ignore all logfiles and tempfiles.
+/log/*.log
+/tmp

data/spec/rails_app/README.rdoc

@@ -1,28 +1,261 @@
-== README
+== Welcome to Rails
 
-This README would normally document whatever steps are necessary to get the
-application up and running.
+Rails is a web-application framework that includes everything needed to create
+database-backed web applications according to the Model-View-Control pattern.
 
-Things you may want to cover:
+This pattern splits the view (also called the presentation) into "dumb"
+templates that are primarily responsible for inserting pre-built data in between
+HTML tags. The model contains the "smart" domain objects (such as Account,
+Product, Person, Post) that holds all the business logic and knows how to
+persist themselves to a database. The controller handles the incoming requests
+(such as Save New Account, Update Product, Show Post) by manipulating the model
+and directing data to the view.
 
-* Ruby version
+In Rails, the model is handled by what's called an object-relational mapping
+layer entitled Active Record. This layer allows you to present the data from
+database rows as objects and embellish these data objects with business logic
+methods. You can read more about Active Record in
+link:files/vendor/rails/activerecord/README.html.
 
-* System dependencies
+The controller and view are handled by the Action Pack, which handles both
+layers by its two parts: Action View and Action Controller. These two layers
+are bundled in a single package due to their heavy interdependence. This is
+unlike the relationship between the Active Record and Action Pack that is much
+more separate. Each of these packages can be used independently outside of
+Rails. You can read more about Action Pack in
+link:files/vendor/rails/actionpack/README.html.
 
-* Configuration
 
-* Database creation
+== Getting Started
 
-* Database initialization
+1. At the command prompt, create a new Rails application:
+       <tt>rails new myapp</tt> (where <tt>myapp</tt> is the application name)
 
-* How to run the test suite
+2. Change directory to <tt>myapp</tt> and start the web server:
+       <tt>cd myapp; rails server</tt> (run with --help for options)
 
-* Services (job queues, cache servers, search engines, etc.)
+3. Go to http://localhost:3000/ and you'll see:
+       "Welcome aboard: You're riding Ruby on Rails!"
 
-* Deployment instructions
+4. Follow the guidelines to start developing your application. You can find
+the following resources handy:
 
-* ...
+* The Getting Started Guide: http://guides.rubyonrails.org/getting_started.html
+* Ruby on Rails Tutorial Book: http://www.railstutorial.org/
 
 
-Please feel free to use a different markup language if you do not plan to run
-<tt>rake doc:app</tt>.
+== Debugging Rails
+
+Sometimes your application goes wrong. Fortunately there are a lot of tools that
+will help you debug it and get it back on the rails.
+
+First area to check is the application log files. Have "tail -f" commands
+running on the server.log and development.log. Rails will automatically display
+debugging and runtime information to these files. Debugging info will also be
+shown in the browser on requests from 127.0.0.1.
+
+You can also log your own messages directly into the log file from your code
+using the Ruby logger class from inside your controllers. Example:
+
+  class WeblogController < ActionController::Base
+    def destroy
+      @weblog = Weblog.find(params[:id])
+      @weblog.destroy
+      logger.info("#{Time.now} Destroyed Weblog ID ##{@weblog.id}!")
+    end
+  end
+
+The result will be a message in your log file along the lines of:
+
+  Mon Oct 08 14:22:29 +1000 2007 Destroyed Weblog ID #1!
+
+More information on how to use the logger is at http://www.ruby-doc.org/core/
+
+Also, Ruby documentation can be found at http://www.ruby-lang.org/. There are
+several books available online as well:
+
+* Programming Ruby: http://www.ruby-doc.org/docs/ProgrammingRuby/ (Pickaxe)
+* Learn to Program: http://pine.fm/LearnToProgram/ (a beginners guide)
+
+These two books will bring you up to speed on the Ruby language and also on
+programming in general.
+
+
+== Debugger
+
+Debugger support is available through the debugger command when you start your
+Mongrel or WEBrick server with --debugger. This means that you can break out of
+execution at any point in the code, investigate and change the model, and then,
+resume execution! You need to install ruby-debug to run the server in debugging
+mode. With gems, use <tt>sudo gem install ruby-debug</tt>. Example:
+
+  class WeblogController < ActionController::Base
+    def index
+      @posts = Post.all
+      debugger
+    end
+  end
+
+So the controller will accept the action, run the first line, then present you
+with a IRB prompt in the server window. Here you can do things like:
+
+  >> @posts.inspect
+  => "[#<Post:0x14a6be8
+          @attributes={"title"=>nil, "body"=>nil, "id"=>"1"}>,
+       #<Post:0x14a6620
+          @attributes={"title"=>"Rails", "body"=>"Only ten..", "id"=>"2"}>]"
+  >> @posts.first.title = "hello from a debugger"
+  => "hello from a debugger"
+
+...and even better, you can examine how your runtime objects actually work:
+
+  >> f = @posts.first
+  => #<Post:0x13630c4 @attributes={"title"=>nil, "body"=>nil, "id"=>"1"}>
+  >> f.
+  Display all 152 possibilities? (y or n)
+
+Finally, when you're ready to resume execution, you can enter "cont".
+
+
+== Console
+
+The console is a Ruby shell, which allows you to interact with your
+application's domain model. Here you'll have all parts of the application
+configured, just like it is when the application is running. You can inspect
+domain models, change values, and save to the database. Starting the script
+without arguments will launch it in the development environment.
+
+To start the console, run <tt>rails console</tt> from the application
+directory.
+
+Options:
+
+* Passing the <tt>-s, --sandbox</tt> argument will rollback any modifications
+  made to the database.
+* Passing an environment name as an argument will load the corresponding
+  environment. Example: <tt>rails console production</tt>.
+
+To reload your controllers and models after launching the console run
+<tt>reload!</tt>
+
+More information about irb can be found at:
+link:http://www.rubycentral.org/pickaxe/irb.html
+
+
+== dbconsole
+
+You can go to the command line of your database directly through <tt>rails
+dbconsole</tt>. You would be connected to the database with the credentials
+defined in database.yml. Starting the script without arguments will connect you
+to the development database. Passing an argument will connect you to a different
+database, like <tt>rails dbconsole production</tt>. Currently works for MySQL,
+PostgreSQL and SQLite 3.
+
+== Description of Contents
+
+The default directory structure of a generated Ruby on Rails application:
+
+  |-- app
+  |   |-- assets
+  |   |   |-- images
+  |   |   |-- javascripts
+  |   |   `-- stylesheets
+  |   |-- controllers
+  |   |-- helpers
+  |   |-- mailers
+  |   |-- models
+  |   `-- views
+  |       `-- layouts
+  |-- config
+  |   |-- environments
+  |   |-- initializers
+  |   `-- locales
+  |-- db
+  |-- doc
+  |-- lib
+  |   |-- assets
+  |   `-- tasks
+  |-- log
+  |-- public
+  |-- script
+  |-- test
+  |   |-- fixtures
+  |   |-- functional
+  |   |-- integration
+  |   |-- performance
+  |   `-- unit
+  |-- tmp
+  |   `-- cache
+  |       `-- assets
+  `-- vendor
+      |-- assets
+      |   |-- javascripts
+      |   `-- stylesheets
+      `-- plugins
+
+app
+  Holds all the code that's specific to this particular application.
+
+app/assets
+  Contains subdirectories for images, stylesheets, and JavaScript files.
+
+app/controllers
+  Holds controllers that should be named like weblogs_controller.rb for
+  automated URL mapping. All controllers should descend from
+  ApplicationController which itself descends from ActionController::Base.
+
+app/models
+  Holds models that should be named like post.rb. Models descend from
+  ActiveRecord::Base by default.
+
+app/views
+  Holds the template files for the view that should be named like
+  weblogs/index.html.erb for the WeblogsController#index action. All views use
+  eRuby syntax by default.
+
+app/views/layouts
+  Holds the template files for layouts to be used with views. This models the
+  common header/footer method of wrapping views. In your views, define a layout
+  using the <tt>layout :default</tt> and create a file named default.html.erb.
+  Inside default.html.erb, call <% yield %> to render the view using this
+  layout.
+
+app/helpers
+  Holds view helpers that should be named like weblogs_helper.rb. These are
+  generated for you automatically when using generators for controllers.
+  Helpers can be used to wrap functionality for your views into methods.
+
+config
+  Configuration files for the Rails environment, the routing map, the database,
+  and other dependencies.
+
+db
+  Contains the database schema in schema.rb. db/migrate contains all the
+  sequence of Migrations for your schema.
+
+doc
+  This directory is where your application documentation will be stored when
+  generated using <tt>rake doc:app</tt>
+
+lib
+  Application specific libraries. Basically, any kind of custom code that
+  doesn't belong under controllers, models, or helpers. This directory is in
+  the load path.
+
+public
+  The directory available for the web server. Also contains the dispatchers and the
+  default HTML files. This should be set as the DOCUMENT_ROOT of your web
+  server.
+
+script
+  Helper scripts for automation and generation.
+
+test
+  Unit and functional tests along with fixtures. When using the rails generate
+  command, template test files will be generated for you and placed in this
+  directory.
+
+vendor
+  External libraries that the application depends on. Also includes the plugins
+  subdirectory. If the app has frozen rails, those gems also go here, under
+  vendor/rails/. This directory is in the load path.

data/spec/rails_app/Rakefile

@@ -1,3 +1,4 @@
+#!/usr/bin/env rake
 # Add your own tasks in files placed in lib/tasks ending in .rake,
 # for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
 

data/spec/rails_app/app/assets/javascripts/application.js

@@ -5,12 +5,11 @@
 // or vendor/assets/javascripts of plugins, if any, can be referenced here using a relative path.
 //
 // It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
-// compiled file.
+// the compiled file.
 //
-// Read Sprockets README (https://github.com/sstephenson/sprockets#sprockets-directives) for details
-// about supported directives.
+// WARNING: THE FIRST BLANK LINE MARKS THE END OF WHAT'S TO BE PROCESSED, ANY BLANK LINE SHOULD
+// GO AFTER THE REQUIRES BELOW.
 //
 //= require jquery
 //= require jquery_ujs
-//= require turbolinks
 //= require_tree .

data/spec/rails_app/app/controllers/application_controller.rb

@@ -1,5 +1,3 @@
 class ApplicationController < ActionController::Base
-  # Prevent CSRF attacks by raising an exception.
-  # For APIs, you may want to use :null_session instead.
-  protect_from_forgery with: :exception
+  protect_from_forgery
 end