stormpath-rails 1.0.0.beta.2 → 1.1.0.beta

data/spec/client_spec.rb

@@ -1,222 +0,0 @@
-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

@@ -1,19 +0,0 @@
-require "active_support/core_ext/class/attribute_accessors"
-require "generator_spec/test_case"
-require "generators/stormpath/rails/migration/migration_generator"
-
-describe Stormpath::Rails::Generators::MigrationGenerator do
-  include GeneratorSpec::TestCase
-  destination File.expand_path("../tmp", __FILE__)
-  arguments %w(person)
-
-  before do
-    Time.stub_chain(:now, :utc, :strftime).and_return("0")
-    prepare_destination
-    run_generator
-  end
-
-  it "creates configuration file" do
-    assert_file "db/migrate/0_add_stormpath_url_to_people.rb", "class AddStormpathUrlToPeople < ActiveRecord::Migration\n  def up\n    add_column :people, :stormpath_url, :string\n    add_index :people, :stormpath_url\n  end\n\n  def down\n    remove_column :people, :stormpath_url\n  end\nend"
-  end
-end

data/spec/integration/active_record_spec.rb

@@ -1,23 +0,0 @@
-require "spec_helper"
-require "active_record"
-require "stormpath-rails"
-
-describe "ActiveRecord record" do
-  class ArEntity < ActiveRecord::Base
-    include Stormpath::Rails::Account
-  end
-
-  subject { ArEntity.new }
-
-  before(:each) do
-    ActiveRecord::Base.establish_connection :adapter => 'sqlite3', :database => ':memory:'
-    ActiveRecord::Migration.verbose = false
-    ActiveRecord::Migration.create_table :ar_entities do |t|
-      t.string :id
-      t.string :stormpath_url
-    end
-  end
-
-  it_should_behave_like "stormpath account"
-
-end

data/spec/integration/mongoid_spec.rb

@@ -1,19 +0,0 @@
-require "spec_helper"
-require 'mongoid'
-require "stormpath-rails"
-
-describe "Mongoid document" do
-  class MongoidEntity
-    include Mongoid::Document
-    include Stormpath::Rails::Account
-  end
-
-  subject { MongoidEntity.new }
-
-  before(:each) do
-    Mongoid::Config.connect_to("stormpath_rails_test")
-  end
-
-  it_should_behave_like "stormpath account"
-
-end

data/spec/spec_helper.rb

@@ -1,96 +0,0 @@
-# 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,212 +0,0 @@
-require "logger"
-
-shared_examples "stormpath account" do
-  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
-
-  context 'class methods' do
-    let(:username) { 'test@example.com' }
-    let(:email) { username }
-    let(:password) { 'adsf1234' }
-    let(:mock_user) { subject.class.new }
-
-    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
-    end
-  end
-
-  before(:each) do
-    Stormpath::Rails::Client.stub!(:find_account).and_return(mock_account)
-    Stormpath::Rails.logger = Logger.new(STDERR)
-  end
-
-  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 '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(mock_account)
-        subject.save!
-      end
-
-      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 }
-
-    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
-
-    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
-      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(Stormpath::Error.new(mock("error", message: "Create failed")))
-      subject.save
-      subject.errors[:base].should == ["Create failed"]
-    end
-  end
-
-  context "before update" do
-    before(:each) do
-      Stormpath::Rails::Client.stub!(:create_account!).and_return(mock_account)
-      subject.save!
-    end
-
-    it "skip silently stormpath update if no stormpath_url set" do
-      subject.stormpath_url = nil
-      expect { subject.save! }.to_not raise_error
-    end
-
-    it "should update account at stormpath" do
-      subject.stormpath_account.should_receive(:save)
-      subject.save!
-    end
-
-    it "should add error if stormpath account update failed" do
-      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
-    before(:each) do
-      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
-      expect { subject.destroy }.to_not raise_error
-    end
-
-    it "should destroy account at stormpath" do
-      subject.stormpath_account.should_receive(:delete)
-      subject.destroy
-    end
-
-    it "should log warning if stormpath account update failed" do
-      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
-end