Setup basic spec state and extract common behavior

This is in preparation for the new caching changes. Since the default
test cache is the [`NullStore`](http://api.rubyonrails.org/classes/ActiveSupport/Cache/NullStore.html)
we need to ensure we test the cache behavior. Since we don't know what
side-effects enabling the cache for the entire test suite will result
in, we enable it only for these specs. Since it's likely that we will
want to test caching in other parts of the code later, we make put this
common setup into a support module.

We choose the in-memory cache as these are tests and we want them to be
fast. The in-memory cache requires no external dependencies and is one
of the fastest cache options.

We know all forms of the cache state will still require munging of the
headers. So since we're extracting common behavior we moved the header
munging logic in to a shared example set.

Author: cupakromer

spec/kracken/controllers/token_authenticatable_spec.rb

@@ -1,4 +1,5 @@
 require "support/base_controller_double"
+require "support/using_cache"
 
 module Kracken
   class TokenAuthController < BaseControllerDouble
@@ -19,43 +20,16 @@ def authenticate_or_request_with_http_token(realm = nil)
   end
 
   RSpec.describe Controllers::TokenAuthenticatable do
-    describe "authenticating via a token" do
-      context "on a cache hit" do
-        it "munges the request headers to support parameterized tokens"
-        it "leaves the request header unchange when with no parameterized token"
-        it "uses the exising cache to bypass the authentication process"
-        it "returns the auth info"
-        it "exposes the auth info via the `current_` helpers"
-        it "lazy loads the current user"
-      end
+    describe "authenticating via a token", :using_cache do
+      shared_examples "the authorization request headers" do |token_helper|
+        let(:expected_token) { public_send token_helper }
 
-      context "on a cache miss with an invalid token" do
-        it "munges the request headers to support parameterized tokens"
-        it "leaves the request header unchange when with no parameterized token"
-        it "follows the token authentication process"
-        it "returns nil"
-        it "doesn't cache invalid tokens"
-      end
-
-      context "on a cache miss with a valid token" do
-        before do
-          allow(Authenticator).to receive(:user_with_token)
-        end
-
-        it "follows the token authentication process"
-        it "returns the auth info"
-        it "exposes the auth info via the `current_` helpers"
-        it "sets the auth info as the cache value"
-        it "sets the cache expiration to one minute by default"
-        it "sets the cache expiration to the environment setting `KRACKEN_TOKEN_TTL` when available"
-        it "eager loads the current user"
-
-        it "munges the request headers to support parameterized tokens" do
+        specify "are munged to include a provided parameterized token" do
           controller = TokenAuthController.new
           controller.request.env = {
             'HTTP_AUTHORIZATION' => 'Token token="header token"'
           }
-          controller.params = { token: "param token" }
+          controller.params = { token: expected_token }
 
           expect {
             controller.authenticate_user_with_token!
@@ -64,27 +38,79 @@ def authenticate_or_request_with_http_token(realm = nil)
           }.from(
             'HTTP_AUTHORIZATION' => 'Token token="header token"'
           ).to(
-            'HTTP_AUTHORIZATION' => 'Token token="param token"'
+            'HTTP_AUTHORIZATION' => "Token token=\"#{expected_token}\""
           )
         end
 
-        it "leaves the request header unchange when with no parameterized token" do
+        specify "are not modified when no parameterized token provided" do
           controller = TokenAuthController.new
           controller.request.env = {
-            'HTTP_AUTHORIZATION' => 'Token token="any token"'
+            'HTTP_AUTHORIZATION' => "Token token=\"#{expected_token}\""
           }
 
           expect {
             controller.authenticate_user_with_token!
           }.not_to change { controller.request.env }.from(
-            'HTTP_AUTHORIZATION' => 'Token token="any token"'
+            'HTTP_AUTHORIZATION' => "Token token=\"#{expected_token}\""
           )
         end
+      end
 
-        it "authenticates the current user via the token" do
-          a_user = instance_double(User)
-          allow(Authenticator).to receive(:user_with_token).with("any token")
+      context "on a cache hit" do
+        let(:cached_token) { "any token" }
+        let(:cache_key) { "auth/token/any token" }
+
+        before do
+          Rails.cache.write(cache_key, "auth info")
+        end
+
+        include_examples "the authorization request headers", :cached_token
+
+        it "uses the exising cache to bypass the authentication process"
+        it "returns the auth info"
+        it "exposes the auth info via the `current_` helpers"
+        it "lazy loads the current user"
+      end
+
+      context "on a cache miss with an invalid token" do
+        let(:invalid_token) { "any token" }
+
+        before do
+          allow(Authenticator).to receive(:user_with_token).with(invalid_token)
+                                                           .and_return(nil)
+        end
+
+        include_examples "the authorization request headers", :invalid_token
+
+        it "follows the token authentication process"
+        it "returns nil"
+        it "doesn't cache invalid tokens"
+      end
+
+      context "on a cache miss with a valid token" do
+        let(:a_user) {
+          instance_double(User, id: user_id, team_ids: some_team_ids)
+        }
+        let(:some_team_ids) { [:some, :team, :ids] }
+        let(:user_id) { :any_id }
+        let(:valid_token) { "any token" }
+
+        before do
+          allow(Authenticator).to receive(:user_with_token).with(valid_token)
                                                            .and_return(a_user)
+        end
+
+        include_examples "the authorization request headers", :valid_token
+
+        it "follows the token authentication process"
+        it "returns the auth info"
+        it "exposes the auth info via the `current_` helpers"
+        it "sets the auth info as the cache value"
+        it "sets the cache expiration to one minute by default"
+        it "sets the cache expiration to the environment setting `KRACKEN_TOKEN_TTL` when available"
+        it "eager loads the current user"
+
+        it "authenticates the current user via the token" do
           controller = TokenAuthController.new
           controller.request.env = {
             'HTTP_AUTHORIZATION' => 'Token token="any token"'

spec/support/using_cache.rb

@@ -0,0 +1,14 @@
+RSpec.shared_context "using Rails cache", :using_cache do
+  before(:context) do
+    @org_cache = Rails.cache
+    Rails.cache = ActiveSupport::Cache.lookup_store(:memory_store)
+  end
+
+  after(:context) do
+    Rails.cache = @org_cache
+  end
+
+  before do
+    Rails.cache.clear
+  end
+end