authkit 0.4.0 → 0.5.0

data/lib/generators/authkit/templates/spec/models/auth_spec.rb

@@ -0,0 +1,18 @@
+require 'rails_helper'
+
+describe Auth do
+  let(:auth_params) { attributes_for(:auth) }
+
+  it "finds the full name"
+  it "returns the provider name if there is no full name"
+  it "finds the first name"
+  it "finds the last name"
+  it "finds the image url"
+  it "finds the image for a tumblr url"
+  it "finds the username"
+  it "does not find a username for google"
+  it "has provider specific tests"
+  it "knows how to refresh google tokens"
+  it "returns a formatted provider name"
+  it "parses the env"
+end

data/lib/generators/authkit/templates/spec/models/user_spec.rb

@@ -1,32 +1,25 @@
-require 'spec_helper'
+require 'rails_helper'
 
 describe User do
   let(:user_params) { attributes_for(:user) }
 
   it "has secure password support" do
-    User.new.should respond_to(:authenticate)
+    expect(User.new).to respond_to(:authenticate)
   end
 
   it "has one time password support" do
-    User.new.should respond_to(:otp_secret_key)
+    expect(User.new).to respond_to(:otp_secret_key)
   end
 
   it "accepts a password confirmation" do
-    User.new.should respond_to(:password_confirmation=)
+    expect(User.new).to respond_to(:password_confirmation=)
   end
 
   it "downcases the email address" do
     user = User.new
     user.email = "SIR@CAPSALOCK.COM"
     user.valid?
-    user.email.should == "sir@capsalock.com"
-  end
-
-  it "knows if the password was set" do
-    user = User.new
-    user.send(:password_set?).should == false
-    user.password = "example"
-    user.send(:password_set?).should == true
+    expect(user.email).to eq("sir@capsalock.com")
   end
 
   describe "validations" do
@@ -34,19 +27,20 @@ describe User do
       before(:each) do
         create(:user)
       end
-      it { should validate_uniqueness_of(:username) }
-      it { should validate_uniqueness_of(:email) }
+      <% if username? %>it { should validate_uniqueness_of(:username) }
+      <% end %>it { should validate_uniqueness_of(:email) }
       it "validates the uniqueness of the the confirmation email" do
-        user = User.new(user_params.merge(email: "old@example.com", username: "old"))
+        existing_user = create(:user)
+        user = build(:user, email: "old@example.com")
         user.confirmation_email = "new@example.com"
-        user.should be_valid
-        user.confirmation_email = "test@example.com"
-        user.should_not be_valid
+        expect(user).to be_valid
+        user.confirmation_email = existing_user.email
+        expect(user).to_not be_valid
       end
     end
     it { should validate_presence_of(:confirmation_email) }
-    it { should validate_presence_of(:username) }
-    it { should validate_presence_of(:password) }
+    <% if username? %>it { should validate_presence_of(:username) }
+    <% end %>it { should validate_presence_of(:password) }
     it { should validate_confirmation_of(:password) }
 
   end
@@ -54,65 +48,65 @@ describe User do
   describe "tokens" do
     it "sets the remember token" do
       user = User.new
-      user.should_receive(:save!).and_return(true)
+      expect(user).to receive(:save!).and_return(true)
       user.set_remember_token
-      user.remember_token.should_not be_blank
-      user.remember_token_created_at.should_not be_blank
+      expect(user.remember_token).to_not be_blank
+      expect(user.remember_token_created_at).to_not be_blank
     end
 
     it "clears the remember token" do
       user = User.new
-      user.should_receive(:save!).and_return(true)
+      expect(user).to receive(:save!).and_return(true)
       user.remember_token = "TOKEN"
       user.remember_token_created_at = Time.now
       user.clear_remember_token
-      user.remember_token.should be_nil
-      user.remember_token_created_at.should be_nil
+      expect(user.remember_token).to be_nil
+      expect(user.remember_token_created_at).to be_nil
     end
   end
 
   describe "token expiry" do
     it "should expire reset password tokens" do
       user = User.new
-      user.reset_password_token_expired?.should == true
+      expect(user.reset_password_token_expired?).to eq(true)
       user.reset_password_token_created_at = 10.minutes.ago
-      user.reset_password_token_expired?.should == false
+      expect(user.reset_password_token_expired?).to eq(false)
       user.reset_password_token_created_at = 1.day.ago
-      user.reset_password_token_expired?.should == true
+      expect(user.reset_password_token_expired?).to eq(true)
     end
 
     it "should expire confirmation tokens" do
       user = User.new
-      user.confirmation_token_expired?.should == true
+      expect(user.confirmation_token_expired?).to eq(true)
       user.confirmation_token_created_at = 2.days.ago
-      user.confirmation_token_expired?.should == false
+      expect(user.confirmation_token_expired?).to eq(false)
       user.confirmation_token_created_at = 3.days.ago
-      user.confirmation_token_expired?.should == true
+      expect(user.confirmation_token_expired?).to eq(true)
     end
 
     it "should expire remember tokens" do
       user = User.new
-      user.remember_token_expired?.should == true
+      expect(user.remember_token_expired?).to eq(true)
       user.remember_token_created_at = 30.days.ago
-      user.remember_token_expired?.should == false
+      expect(user.remember_token_expired?).to eq(false)
       user.remember_token_created_at = 1.years.ago
-      user.remember_token_expired?.should == true
+      expect(user.remember_token_expired?).to eq(true)
     end
   end
 
   describe "display name" do
     it "has a display name" do
       user = User.new(first_name: "Boss", last_name: "Hogg")
-      user.display_name.should == "Boss Hogg"
+      expect(user.full_name).to eq("Boss Hogg")
       user.first_name = nil
-      user.display_name.should == "Hogg"
+      expect(user.full_name).to eq("Hogg")
     end
   end
 
   describe "tracking" do
     let(:user) do
       user = User.new
-      user.should_receive(:save).and_return(true)
+      expect(user).to receive(:save).and_return(true)
       user
     end
 
@@ -123,28 +117,28 @@ describe User do
     end
 
     it "tracks current sign in" do
-      Time.stub(:now).and_return(time = Time.now)
+      allow(Time).to receive(:now).and_return(time = Time.now)
       user.track_sign_in(nil)
-      user.current_sign_in_at.should == time
+      expect(user.current_sign_in_at).to eq(time)
     end
 
     it "tracks last sign in" do
       time = Time.now
       user.current_sign_in_at = time
       user.track_sign_in(nil)
-      user.last_sign_in_at.should == time
+      expect(user.last_sign_in_at).to eq(time)
     end
 
     it "tracks current and last ip" do
       user.track_sign_in(ip = "123.456.789.001")
-      user.current_sign_in_ip.should == ip
+      expect(user.current_sign_in_ip).to eq(ip)
     end
 
     it "tracks current and last ip" do
       ip = "123.456.789.001"
       user.current_sign_in_ip = ip
       user.track_sign_in(nil)
-      user.last_sign_in_ip.should == ip
+      expect(user.last_sign_in_ip).to eq(ip)
     end
   end
 
@@ -154,110 +148,110 @@ describe User do
     describe "with valid params" do
       it "confirms the email" do
         user = User.new
-        user.should_receive(:save!).and_return(true)
-        Time.stub(:now).and_return(time = Time.now)
+        expect(user).to receive(:save!).and_return(true)
+        allow(Time).to receive(:now).and_return(time = Time.now)
 
         user.send_confirmation
-        user.confirmation_token_created_at.should == time
-        user.confirmation_token.should_not be_blank
+        expect(user.confirmation_token_created_at).to eq(time)
+        expect(user.confirmation_token).to_not be_blank
       end
 
       it "generates a token before it sends confirmation email instructions" do
         user = User.new
-        user.should_receive(:save!).and_return(true)
+        expect(user).to receive(:save!).and_return(true)
         user.send_confirmation
-        user.confirmation_token.should_not be_blank
-        user.confirmation_token_created_at.should_not be_blank
+        expect(user.confirmation_token).to_not be_blank
+        expect(user.confirmation_token_created_at).to_not be_blank
       end
 
       it "sends confirmation email instructions" do
         user = User.new
-        user.should_receive(:save!).and_return(true)
+        expect(user).to receive(:save!).and_return(true)
         user.send_confirmation
       end
 
       it "handles confirmed emails" do
-        user.should_receive(:save).and_return(true)
+        expect(user).to receive(:save).and_return(true)
         user.confirmation_email = "new@example.com"
         user.confirmation_token = "TOKEN"
-        user.email_confirmed.should == true
-        user.confirmation_email.should == user.email
-        user.confirmation_token.should be_nil
-        user.confirmation_token_created_at.should be_nil
-        user.email.should == "new@example.com"
+        expect(user.email_confirmed).to eq(true)
+        expect(user.confirmation_email).to eq(user.email)
+        expect(user.confirmation_token).to be_nil
+        expect(user.confirmation_token_created_at).to be_nil
+        expect(user.email).to eq("new@example.com")
       end
     end
 
     it "does not confirm if there is no confirmation token" do
       user.confirmation_email = "new@example.com"
       user.confirmation_token = nil
-      user.email_confirmed.should == false
+      expect(user.email_confirmed).to eq(false)
     end
 
     it "does not confirm if there is no confirmation email" do
       user.confirmation_email = ""
       user.confirmation_token = "TOKEN"
-      user.email_confirmed.should == false
+      expect(user.email_confirmed).to eq(false)
     end
 
     it "does not confirm emails if they are already used" do
-      create(:user, email: "new@example.com", username: "newuser")
+      create(:user, email: "new@example.com")
       user.confirmation_email = "new@example.com"
       user.confirmation_token = "TOKEN"
-      user.email_confirmed.should == false
-      user.should have(1).errors_on(:email)
+      expect(user.email_confirmed).to eq(false)
+      expect(user.errors[:email].size).to eq(1)
     end
 
     it "is pending confirmation if there is a confirmation token" do
       user = build(:user, confirmation_token: "TOKEN")
-      user.should be_pending_confirmation
+      expect(user).to be_pending_confirmation
     end
 
     it "there is no pending confirmation if there is not a confirmation token" do
       user = build(:user, confirmation_token: nil)
-      user.should_not be_pending_confirmation
+      expect(user).to_not be_pending_confirmation
     end
   end
 
   describe "passwords" do
     it "changes the password if it matches" do
       user = build(:user)
-      user.should_receive(:save).and_return(true)
+      expect(user).to receive(:save).and_return(true)
       user.change_password("password", "password")
-      user.password_digest.should_not be_blank
-      user.remember_token.should be_nil
-      user.remember_token_created_at.should be_nil
+      expect(user.password_digest).to_not be_blank
+      expect(user.remember_token).to be_nil
+      expect(user.remember_token_created_at).to be_nil
     end
 
     it "doesn't change the password if it doesn't match" do
       user = User.new
       user.remember_token = "token"
       user.change_password("password", "typotypo")
-      user.should_not be_valid
-      user.remember_token.should == "token"
+      expect(user).to_not be_valid
+      expect(user.remember_token).to eq("token")
     end
 
     it "resets the password" do
       user = User.new
-      user.should_receive(:save!).and_return(true)
-      Time.stub(:now).and_return(time = Time.now)
+      expect(user).to receive(:save!).and_return(true)
+      allow(Time).to receive(:now).and_return(time = Time.now)
 
       user.send_reset_password
-      user.reset_password_token_created_at.should == time
-      user.reset_password_token.should_not be_blank
+      expect(user.reset_password_token_created_at).to eq(time)
+      expect(user.reset_password_token).to_not be_blank
     end
 
     it "generates a token before it sends reset password instructions" do
       user = User.new
-      user.should_receive(:save!).and_return(true)
+      expect(user).to receive(:save!).and_return(true)
       user.send_reset_password
-      user.reset_password_token.should_not be_blank
-      user.reset_password_token_created_at.should_not be_blank
+      expect(user.reset_password_token).to_not be_blank
+      expect(user.reset_password_token_created_at).to_not be_blank
     end
 
     it "sends reset password instructions" do
       user = User.new
-      user.should_receive(:save!).and_return(true)
+      expect(user).to receive(:save!).and_return(true)
       user.send_reset_password
     end
   end

data/spec/rails_helper.rb

@@ -0,0 +1,50 @@
+# This file is copied to spec/ when you run 'rails generate rspec:install'
+ENV["RAILS_ENV"] ||= 'test'
+require 'spec_helper'
+require File.expand_path('../tmp/sample/config/environment', __FILE__)
+require 'rspec/rails'
+require 'factory_girl'
+
+# Requires supporting ruby files with custom matchers and macros, etc, in
+# spec/support/ and its subdirectories. Files matching `spec/**/*_spec.rb` are
+# run as spec files by default. This means that files in spec/support that end
+# in _spec.rb will both be required and run as specs, causing the specs to be
+# run twice. It is recommended that you do not name files matching this glob to
+# end with _spec.rb. You can configure this pattern with the --pattern
+# option on the command line or in ~/.rspec, .rspec or `.rspec-local`.
+Dir[Rails.root.join("spec/support/**/*.rb")].each { |f| require f }
+
+# Checks for pending migrations before tests are run.
+# If you are not using ActiveRecord, you can remove this line.
+ActiveRecord::Migration.maintain_test_schema!
+
+RSpec.configure do |config|
+
+  # Remove this line if you're not using ActiveRecord or ActiveRecord fixtures
+  config.fixture_path = "#{::Rails.root}/spec/fixtures"
+
+  # If you're not using ActiveRecord, or you'd prefer not to run each of your
+  # examples within a transaction, remove the following line or assign false
+  # instead of true.
+  config.use_transactional_fixtures = true
+
+  # RSpec Rails can automatically mix in different behaviours to your tests
+  # based on their file location, for example enabling you to call `get` and
+  # `post` in specs under `spec/controllers`.
+  #
+  # You can disable this behaviour by removing the line below, and instead
+  # explicitly tag your specs with their type, e.g.:
+  #
+  #     RSpec.describe UsersController, :type => :controller do
+  #       # ...
+  #     end
+  #
+  # The different available types are documented in the features, such as in
+  # https://relishapp.com/rspec/rspec-rails/docs
+  config.infer_spec_type_from_file_location!
+  config.infer_base_class_for_anonymous_controllers = false
+
+  # FactoryGirl allows you to quickly create template based objects
+  # The syntax methods give you inline `create` and a `build` commands
+  config.include FactoryGirl::Syntax::Methods
+end

data/spec/spec_helper.rb

@@ -1,18 +1,75 @@
-ENV["RAILS_ENV"] ||= 'test'
-require File.expand_path('../tmp/sample/config/environment', __FILE__)
-require 'rspec/rails'
-require 'rspec/autorun'
+# This file was generated by the `rails generate rspec:install` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause this
+# file to always be loaded, without a need to explicitly require it in any files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, make a
+# separate helper file that requires this one and then use it only in the specs
+# that actually need it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
 
-Dir[Rails.root.join("spec/support/**/*.rb")].each { |f| require f }
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
 
-ActiveRecord::Migration.check_pending! if defined?(ActiveRecord::Migration)
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
 
-RSpec.configure do |config|
-  config.use_transactional_fixtures = true
-  config.infer_base_class_for_anonymous_controllers = false
-  config.order = "random"
-  config.include FactoryGirl::Syntax::Methods
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
 
-  # Because we are not running things in Rails we need to stub some secrets
-  config.before(:each) { Rails.application.config.stub(:secret_token).and_return("SECRET") }
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # Enable only the newer, non-monkey-patching expect syntax.
+    # For more details, see:
+    #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+    expectations.syntax = :expect
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Enable only the newer, non-monkey-patching expect syntax.
+    # For more details, see:
+    #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+    mocks.syntax = :expect
+
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended.
+    mocks.verify_partial_doubles = true
+  end
 end
+