stormpath-rails 0.4.4 → 1.0.0.beta

data/lib/stormpath/rails/railtie.rb

@@ -0,0 +1,13 @@
+require 'rails'
+
+module Stormpath
+  module Rails
+    mattr_accessor :logger
+
+    class Railtie < ::Rails::Railtie
+      initializer 'Rails logger' do
+        Stormpath::Rails.logger = ::Rails.logger
+      end
+    end
+  end
+end

data/lib/stormpath/rails/version.rb

@@ -1,5 +1,6 @@
 module Stormpath
   module Rails
-    VERSION = "0.4.4"
+    VERSION = '1.0.0.beta'
+    VERSION_DATE = '2013-06-13'
   end
 end

data/spec/client_spec.rb

@@ -0,0 +1,222 @@
+require "spec_helper"
+
+describe Stormpath::Rails::Client, :vcr do
+
+  describe ".client" do
+    context "given a valid Stormpath API key ID and secret" do
+      let(:client) do
+        Stormpath::Rails::Client.client
+      end
+
+      it "should instantiate a Stormpath Client" do
+        expect(client).to be
+        expect(client).to be_kind_of Stormpath::Client
+      end
+
+      it "should instantiate a Stormpath Tenant" do
+        expect(client.tenant).to be
+        expect(client.tenant).to be_kind_of Stormpath::Resource::Tenant
+      end
+    end
+
+    context 'given a composite url' do
+      let(:composite_url) { 'http://ASDF1234:ZXCV5678@example.com/foo/bar' }
+      let(:application) { double 'application' }
+      let(:loaded_client) { double 'client' }
+      let(:returned_client) { Stormpath::Rails::Client.client }
+
+      before do
+        ENV['STORMPATH_URL'] = composite_url
+      end
+
+      it 'loads the client from the application' do
+        Stormpath::Resource::Application
+          .should_receive(:load)
+          .with(composite_url)
+          .and_return(application)
+
+        application
+          .should_receive(:client)
+          .and_return(loaded_client)
+
+        expect(returned_client).to be
+        expect(returned_client).to eq(loaded_client)
+      end
+
+      after do
+        ENV['STORMPATH_URL'] = nil
+      end
+    end
+  end
+
+  describe ".create_account!" do
+    context "given a hash of account attributes" do
+      let(:attributes) do
+        {
+          'email' => 'test+foo+bar@example.com',
+          'given_name' => 'bazzy',
+          'surname' => 'foo',
+          'password' => 'P@66w0rd!',
+          'username' => 'testfoobar'
+        }
+      end
+
+      let(:account) do
+        Stormpath::Rails::Client.create_account! attributes
+      end
+
+      it "should create an account" do
+        expect(account).to be
+        expect(account).to be_kind_of Stormpath::Resource::Account
+        expect(account.given_name).to eq(attributes['given_name'])
+      end
+
+      after do
+        account.delete
+      end
+    end
+  end
+
+  describe ".authenticate_account" do
+    context "given a valid username and password" do
+      let(:username) { 'testfoobar' }
+      let(:password) { 'Succ3ss!' }
+
+      let!(:test_account) do
+        obtain_test_account(
+          'username' => 'testfoobar',
+          'password' => 'Succ3ss!'
+        )
+      end
+
+      let(:authenticated_account) do
+        Stormpath::Rails::Client.authenticate_account(
+          username, password
+        )
+      end
+
+      it "authenticates the account" do
+        expect(authenticated_account).to be
+        expect(authenticated_account).to be_kind_of Stormpath::Resource::Account
+        expect(authenticated_account.username).to eq(username)
+      end
+
+      after do
+        authenticated_account.delete
+      end
+    end
+  end
+
+  describe ".update_account!" do
+    context "given a valid account" do
+      let(:new_name) { "Bartholomew" }
+
+      let(:created_account) do
+        obtain_test_account 'given_name' => 'Foo'
+      end
+
+      let(:reloaded_account) do
+        found_account = nil
+
+        Stormpath::Rails::Client.all_accounts.each do |a|
+          found_account = a unless a.href != created_account.href or !found_account.nil?
+        end
+
+        found_account
+      end
+
+      before do
+        Stormpath::Rails::Client.update_account!(
+          created_account.href, 'given_name' => new_name
+        )
+      end
+
+      it "updates the account" do
+        expect(reloaded_account).to be
+        expect(reloaded_account.given_name).to eq(new_name)
+      end
+
+      after do
+        created_account.delete
+      end
+    end
+  end
+
+  describe ".find_account" do
+    context "given a valid account" do
+      let(:created_account) { obtain_test_account }
+      let(:returned_account) do
+        Stormpath::Rails::Client.find_account(
+          created_account.href
+        )
+      end
+
+      it "returns the account" do
+        expect(returned_account).to be
+        expect(returned_account).to be_kind_of Stormpath::Resource::Account
+        expect(returned_account.href).to eq(created_account.href)
+      end
+
+      after do
+        created_account.delete
+      end
+    end
+  end
+
+  describe ".send_password_reset_email" do
+    context "given a valid account" do
+      let(:created_account) { obtain_test_account }
+      let(:returned_account) do
+        Stormpath::Rails::Client.send_password_reset_email(
+          created_account.email
+        )
+      end
+
+      it "sends the reset email" do
+        expect(returned_account).to be
+        expect(returned_account).to be_kind_of Stormpath::Resource::Account
+        expect(returned_account.href).to eq(created_account.href)
+      end
+
+      after do
+        created_account.delete
+      end
+    end
+  end
+
+  describe '.verify_password_reset_token' do
+    let(:password_reset_token) { 'ASDF1234' }
+    let(:application) { double('application') }
+
+    it 'delegates to the application instance' do
+      Stormpath::Rails::Client
+        .should_receive(:application)
+        .and_return application
+
+      application
+        .should_receive(:verify_password_reset_token)
+        .with(password_reset_token)
+
+      Stormpath::Rails::Client.verify_password_reset_token(
+        password_reset_token
+      )
+    end
+  end
+
+  describe '.verify_account_email' do
+    let(:email_verification_token) { 'ASDF1234' }
+    let(:accounts) { double('accounts') }
+
+    it 'delegates to the application instance' do
+      Stormpath::Rails::Client
+        .stub_chain(:client, :accounts)
+        .and_return(accounts)
+
+      accounts
+        .should_receive(:verify_email_token)
+        .with email_verification_token
+
+      Stormpath::Rails::Client.verify_account_email email_verification_token
+    end
+  end
+end

data/spec/generators/migration_generator_spec.rb

@@ -7,7 +7,7 @@ describe Stormpath::Rails::Generators::MigrationGenerator do
   destination File.expand_path("../tmp", __FILE__)
   arguments %w(person)
 
-  before(:all) do
+  before do
     Time.stub_chain(:now, :utc, :strftime).and_return("0")
     prepare_destination
     run_generator

data/spec/spec_helper.rb

@@ -1,5 +1,96 @@
+# Note: If SimpleCov starts after your application code is already loaded (via require),
+# it won't be able to track your files and their coverage! The SimpleCov.start must be
+# issued before any of your application code is required!
+require 'simplecov'
+SimpleCov.start
+
+require "vcr"
+require "webmock"
+require "pry"
+require "pry-debugger"
+require 'stormpath-rails'
+
 Dir["./spec/support/**/*.rb"].sort.each {|f| require f}
 
+module Stormpath
+  module TestResourceHelpers
+    def reload_client
+      Stormpath::Rails.send(:remove_const, :Client)
+      load 'lib/stormpath/rails/client.rb'
+    end
+
+    def obtain_test_account(opts={})
+      defaults = {
+        'surname' => 'testsurname',
+        'given_name' => 'testgivenname',
+        'username' => 'testfoobar',
+        'password' => 'Succ3ss!',
+        'email' => 'test+foo+bar@example.com'
+      }
+
+      begin
+        Stormpath::Rails::Client.create_account! defaults.merge!(opts)
+      rescue Stormpath::Error => e
+        Stormpath::Rails::Client.authenticate_account(opts['username'], opts['password'])
+      end
+    end
+  end
+
+  class TestEnvironmentConfigurator
+    def self.verify_setup
+      pfx = 'STORMPATH_RAILS_TEST'
+
+      unless (ENV["#{pfx}_API_KEY_SECRET"] and ENV["#{pfx}_API_KEY_ID"]) or ENV["#{pfx}_API_KEY_FILE_LOCATION"]
+        raise <<-message
+          Must specify either STORMPATH_RAILS_TEST_API_KEY_FILE_LOCATION or
+          STORMPATH_RAILS_TEST_API_KEY_SECRET and STORMPATH_RAILS_TEST_API_KEY_ID
+          in order to run tests.
+        message
+      end
+
+      unless ENV["#{pfx}_APPLICATION_URL"]
+        raise <<-message
+          Must specify STORMPATH_RAILS_TEST_APPLICATION_URL so that tests have
+          an Application Resource to run against.
+        message
+      end
+    end
+
+    def self.create_test_env
+      k = %w(SECRET ID FILE_LOCATION ID_PROPERTY_NAME SECRET_PROPERTY_NAME)
+
+      k.each do |v|
+        ENV["STORMPATH_API_KEY_#{v}"] = ENV["STORMPATH_RAILS_TEST_API_KEY_#{v}"]
+      end
+
+      ENV['STORMPATH_APPLICATION_URL'] = ENV['STORMPATH_RAILS_TEST_APPLICATION_URL']
+    end
+
+    def self.prepare_test_environment
+      verify_setup
+      create_test_env
+    end
+  end
+end
+
 RSpec.configure do |config|
+  config.mock_framework = :rspec
   config.order = 'random'
+  config.include Stormpath::TestResourceHelpers
+
+  config.before(:all) do
+    Stormpath::TestEnvironmentConfigurator.prepare_test_environment
+  end
+
+  config.before(:each) do
+    reload_client
+  end
+
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+end
+
+VCR.configure do |c|
+  c.cassette_library_dir = 'spec/fixtures/vcr_cassettes'
+  c.hook_into :webmock
+  c.configure_rspec_metadata!
 end

data/spec/support/stormpath_account_shared_examples.rb

@@ -1,119 +1,211 @@
+require "logger"
+
 shared_examples "stormpath account" do
-  context "after initialize" do
-    let(:account) { mock("account", get_href: "account_href") }
+  let(:mock_account) do
+    mock("account", href: "account_href").tap do |account|
+      subject.class::STORMPATH_FIELDS.each do |field_name|
+        account.stub!("#{field_name}").and_return(field_name.to_s)
+      end
+    end
+  end
 
-    let!(:logger) { Logger.new(STDERR) }
+  context 'class methods' do
+    let(:username) { 'test@example.com' }
+    let(:email) { username }
+    let(:password) { 'adsf1234' }
+    let(:mock_user) { subject.class.new }
 
-    before(:each) do
-      subject.class::STORMPATH_FIELDS.each do |field_name|
-        account.stub!("get_#{field_name}").and_return(field_name.to_s)
+    describe '.authenticate' do
+      before do
+        Stormpath::Rails::Client.stub!(:authenticate_account).and_return(mock_account)
+        subject.class.stub_chain(:where, :first).and_return(mock_user)
+      end
+
+      it 'returns an instance of the class into which the Account module was mixed in' do
+        instance = subject.class.authenticate username, password
+        instance.should be_a_kind_of(subject.class)
+      end
+    end
+
+    describe '.send_password_reset_email' do
+      before do
+        Stormpath::Rails::Client.stub!(:send_password_reset_email).and_return(mock_account)
+        subject.class.stub_chain(:where, :first).and_return(mock_user)
+      end
+
+      it 'returns an instance of the class into which the Account module was mixed in' do
+        instance = subject.class.send_password_reset_email email
+        instance.should be_a_kind_of(subject.class)
+      end
+    end
+
+    describe '.verify_password_reset_token' do
+      let(:token) { 'ASDF1324' }
+
+      before do
+        Stormpath::Rails::Client.stub!(:verify_password_reset_token).and_return(mock_account)
+        subject.class.stub_chain(:where, :first).and_return(mock_user)
+      end
+
+      it 'returns an instance of the class into which the Account module was mixed in' do
+        instance = subject.class.verify_password_reset_token token
+        instance.should be_a_kind_of(subject.class)
+      end
+    end
+
+    describe '.verify_account_email' do
+      let(:token) { 'ASDF1324' }
+
+      before do
+        Stormpath::Rails::Client.stub!(:verify_account_email).and_return(mock_account)
+        subject.class.stub_chain(:where, :first).and_return(mock_user)
+      end
+
+      it 'returns an instance of the class into which the Account module was mixed in' do
+        instance = subject.class.verify_account_email token
+        instance.should be_a_kind_of(subject.class)
       end
-      Logger.stub!(:new).and_return(logger)
-      Stormpath::Rails::Client.stub!(:find_account).and_return(account)
     end
+  end
+
+  before(:each) do
+    Stormpath::Rails::Client.stub!(:find_account).and_return(mock_account)
+    Stormpath::Rails.logger = Logger.new(STDERR)
+  end
 
-    it "should silently skip stormpath load if no stormpath_url set" do
-      Stormpath::Rails::Client.should_not_receive(:find_account)
-      expect { subject }.to_not raise_error
+  context "after initialize" do
+    context 'when no Stormpath URL property is set' do
+      it "does NOT load data from stormpath on initialization" do
+        Stormpath::Rails::Client.should_not_receive(:find_account)
+        expect { subject }.to_not raise_error
+      end
     end
 
-    context "on find" do
+    context 'when a Stormpath URL property is set' do
+      let(:reloaded_subject) { subject.class.all.first }
+
       before(:each) do
-        Stormpath::Rails::Client.stub!(:create_account!).and_return(account)
+        Stormpath::Rails::Client.stub!(:create_account!).and_return(mock_account)
         subject.save!
       end
 
-      it "should find account at stormpath" do
-        Stormpath::Rails::Client.should_receive(:find_account).with(subject.stormpath_url)
-        subject.class.all.first.stormpath_url.should == subject.stormpath_url
+      it "does NOT load data from stormpath on initialization" do
+        Stormpath::Rails::Client.should_not_receive(:find_account)
+        reloaded_subject.stormpath_url.should == subject.stormpath_url
       end
+    end
+  end
+
+  context 'lazy load Stormpath fields' do
+    let(:reloaded_subject) { subject.class.all.first }
 
-      it "should setup object with data from stormpath" do
-        Stormpath::Rails::Client.should_receive(:find_account).with(subject.stormpath_url).and_return(account)
-        found = subject.class.where(stormpath_url: 'account_href').first
-        (subject.class::STORMPATH_FIELDS - [:password]).each do |field_name|
-          found.send(field_name).should == account.send("get_#{field_name}")
+    before(:each) do
+      Stormpath::Rails::Client.stub!(:create_account!).and_return(mock_account)
+      subject.save!
+    end
+
+    context 'when no Stormpath account field has ever been read' do
+      (Stormpath::Rails::Account::STORMPATH_FIELDS - [:password]).each do |field_name|
+        context "when the #{field_name} is read" do
+          it "retrieves the account fields from Stormpath" do
+            Stormpath::Rails::Client.should_receive(:find_account).with(subject.stormpath_url)
+            reloaded_subject.send(field_name).should == mock_account.send(field_name)
+          end
+
+          it "logs a warning to standard output" do
+            Stormpath::Rails::Client.stub!(:find_account).and_raise(Stormpath::Error.new(mock("error", message: "Find failed")))
+            Stormpath::Rails.logger.should_receive(:warn).with("Error loading Stormpath account (Find failed)")
+            reloaded_subject.send(field_name).should be_nil
+          end
         end
       end
+    end
 
-      it "should log warning if stormpath account update failed" do
-        Stormpath::Rails::Client.stub!(:find_account).and_raise(ResourceError.new(mock("error", get_message: "Find failed")))
-        logger.should_receive(:warn).with("Error loading Stormpath account (Find failed)")
-        found = subject.class.where(stormpath_url: 'account_href').first
-        subject.class::STORMPATH_FIELDS.each do |field_name|
-          found.send(field_name).should be_nil
+    context 'when a Stormpath account field has previously been read' do
+      before do
+        Stormpath::Rails::Client.should_receive(:find_account).with(subject.stormpath_url).at_most(:once).and_return(mock_account)
+        reloaded_subject.send :email
+      end
+
+      (Stormpath::Rails::Account::STORMPATH_FIELDS - [:password]).each do |field_name|
+        context "when reading the #{field_name} attribute" do
+          it 'does NOT retrieve the full account from Stormpath' do
+            reloaded_subject.send(field_name).should == mock_account.send(field_name)
+          end
         end
       end
     end
-
   end
 
-
   context "before create" do
+    before(:each) do
+      subject.email = 'foo@example.com'
+      subject.given_name = 'Foo'
+      subject.surname = 'Bar'
+
+      Stormpath::Rails::Client.stub!(:create_account!).and_return mock_account
+    end
+
     it "should create account at stormpath and assign stormpath_url" do
-      Stormpath::Rails::Client.should_receive(:create_account!).and_return(mock("account", get_href: "account_href"))
-      subject.save!
+      subject.stormpath_url.should be_nil
+      Stormpath::Rails::Client.should_receive(:create_account!).once.with(hash_including({
+        :email => 'foo@example.com',
+        :given_name => 'Foo',
+        :surname => 'Bar'
+      }))
+      subject.save
       subject.stormpath_url.should == "account_href"
     end
 
     it "should add error if stormpath account creation failed" do
-      Stormpath::Rails::Client.stub!(:create_account!).and_raise(ResourceError.new(mock("error", get_message: "Create failed")))
+      Stormpath::Rails::Client.stub!(:create_account!).and_raise(Stormpath::Error.new(mock("error", message: "Create failed")))
       subject.save
       subject.errors[:base].should == ["Create failed"]
     end
   end
 
   context "before update" do
-    let(:account) { mock("account", get_href: "account_href") }
-
     before(:each) do
-      Stormpath::Rails::Client.stub!(:create_account!).and_return(account)
+      Stormpath::Rails::Client.stub!(:create_account!).and_return(mock_account)
       subject.save!
     end
 
-    it "should silently skip stormpath update if no stormpath_url set" do
+    it "skip silently stormpath update if no stormpath_url set" do
       subject.stormpath_url = nil
-      Stormpath::Rails::Client.should_not_receive(:update_account!)
       expect { subject.save! }.to_not raise_error
     end
 
     it "should update account at stormpath" do
-      Stormpath::Rails::Client.should_receive(:update_account!).with(subject.stormpath_url, anything())
+      subject.stormpath_account.should_receive(:save)
       subject.save!
     end
 
     it "should add error if stormpath account update failed" do
-      Stormpath::Rails::Client.stub!(:update_account!).and_raise(ResourceError.new(mock("error", get_message: "Update failed")))
+      subject.stormpath_account.stub!(:save).and_raise(Stormpath::Error.new(mock("error", message: "Update failed")))
       subject.save.should be_false
       subject.errors[:base].should == ["Update failed"]
     end
   end
 
   context "after destroy" do
-    let(:account) { mock("account", get_href: "account_href") }
-
-    let!(:logger) { Logger.new(STDERR) }
-
     before(:each) do
-      Logger.stub!(:new).and_return(logger)
-      Stormpath::Rails::Client.stub!(:create_account!).and_return(account)
+      Stormpath::Rails::Client.stub!(:create_account!).and_return(mock_account)
       subject.save!
     end
 
     it "should silently skip stormpath delete if no stormpath_url set" do
       subject.stormpath_url = nil
-      Stormpath::Rails::Client.should_not_receive(:delete_account!)
       expect { subject.destroy }.to_not raise_error
     end
 
     it "should destroy account at stormpath" do
-      Stormpath::Rails::Client.should_receive(:delete_account!).with(subject.stormpath_url)
+      subject.stormpath_account.should_receive(:delete)
       subject.destroy
     end
 
     it "should log warning if stormpath account update failed" do
-      Stormpath::Rails::Client.stub!(:delete_account!).and_raise(ResourceError.new(mock("error", get_message: "Delete failed")))
-      logger.should_receive(:warn).with("Error destroying Stormpath account (Delete failed)")
+      subject.stormpath_account.stub!(:delete).and_raise(Stormpath::Error.new(mock("error", message: "Delete failed")))
+      Stormpath::Rails.logger.should_receive(:warn).with("Error destroying Stormpath account (Delete failed)")
       subject.destroy.should be_true
     end
   end