saasy 0.0.1

data/spec/models/user_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe User, "valid" do
+  subject { Factory(:user) }
+
+  it { should validate_presence_of(:name) }
+
+  it { should have_many(:memberships) }
+  it { should have_many(:accounts).through(:memberships) }
+  it { should have_many(:permissions) }
+  it { should have_many(:projects).through(:permissions) }
+
+  it "is an admin of an account with an admin membership" do
+    account = Factory(:account)
+    Factory(:membership, :user => subject, :admin => true, :account => account)
+    subject.should be_admin_of(account)
+
+    subject.memberships.admin.first.account.should == account
+  end
+
+  it "isn't an admin of an account with a non admin membership" do
+    account = Factory(:account)
+    Factory(:membership, :user => subject, :admin => false, :account => account)
+    subject.should_not be_admin_of(account)
+  end
+
+  it "isn't an admin of an account without a membership" do
+    account = Factory(:account)
+    subject.should_not be_admin_of(account)
+  end
+
+  it "is a member with a membership for the given account" do
+    account = Factory(:account)
+    Factory(:membership, :user => subject, :account => account)
+    subject.should be_member_of(account)
+  end
+
+  it "isn't a member without a membership for the given account" do
+    account = Factory(:account)
+    other_account = Factory(:account)
+    Factory(:membership, :user => subject, :account => other_account)
+    subject.should_not be_member_of(account)
+  end
+
+  it "is a member with a membership for the given project" do
+    project = Factory(:project)
+    membership = Factory(:membership, :user    => subject,
+                                                      :account => project.account)
+    Factory(:permission, :membership => membership,
+                                 :project            => project)
+    subject.should be_member_of(project)
+  end
+
+  it "isn't a member without a membership for the given project" do
+    project = Factory(:project)
+    other_project = Factory(:project)
+    membership = Factory(:membership, :user    => subject,
+                                                      :account => other_project.account)
+    Factory(:permission, :membership => membership,
+                                 :project            => other_project)
+    subject.should_not be_member_of(project)
+  end
+
+  it "returns users by name" do
+    Factory(:user, :name => "def")
+    Factory(:user, :name => "abc")
+    Factory(:user, :name => "ghi")
+
+    User.by_name.map(&:name).should == %w(abc def ghi)
+  end
+end
+

data/spec/route_extensions_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe "Saucy routing extensions" do
+  include ActionDispatch::Routing::UrlFor
+
+  let(:_routes) { ActionDispatch::Routing::RouteSet.new }
+
+  before do
+    _routes.draw do
+      resources :accounts
+      through :accounts do
+        resources :projects
+        through :projects do
+          resources :discussions
+        end
+      end
+    end
+
+    extend(_routes.named_routes.module)
+  end
+
+  it "allows a nested member path to be accessed through just the child's name" do
+    account = stub('account', :to_param => 'abc')
+    project = stub('project', :account => account, :to_param => 'def')
+    project_path(project).should == "/accounts/abc/projects/def"
+  end
+
+  it "allows a nested member url to be accessed through just the child's name" do
+    account = stub('account', :to_param => 'abc')
+    project = stub('project', :account => account, :to_param => 'def')
+    project_url(project, :host => 'example.com').
+      should == "http://example.com/accounts/abc/projects/def"
+  end
+
+  it "allows a nested collection path to be accessed through just the parent's name" do
+    account = stub('account', :to_param => 'abc')
+    projects_path(account).should == "/accounts/abc/projects"
+  end
+
+  it "allows a nested new path to be accessed through just the parent's name" do
+    account = stub('account', :to_param => 'abc')
+    new_project_path(account).should == "/accounts/abc/projects/new"
+  end
+
+  it "allows a doubly nested member path to be access through just the child's name" do
+    account = stub('account', :to_param => 'abc')
+    project = stub('project', :account => account, :to_param => 'def')
+    discussion = stub('discussion', :project => project, :to_param => 'ghi')
+    discussion_path(discussion).should == "/accounts/abc/projects/def/discussions/ghi"
+  end
+end

data/spec/saucy_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe Saucy::Configuration do
+  it "has layouts" do
+    subject.layouts.should be_a(Saucy::Layouts)
+  end
+
+  it "has a manager_email_address" do
+    subject.manager_email_address.should_not be_nil
+  end
+
+  it "has a support_email_address" do
+    subject.support_email_address.should_not be_nil
+  end
+
+  it "has a nil merchant_account_id" do
+    subject.merchant_account_id.should be_nil
+  end
+
+  it "can listen for events" do
+    observer = stub("an observer")
+    cleanup_observers do
+      Saucy::Configuration.observe(observer)
+      Saucy::Configuration.observers.should include(observer)
+    end
+  end
+
+  it "can notify observers" do
+    observer = stub("an observer", :some_event => nil)
+    cleanup_observers do
+      Saucy::Configuration.observe(observer)
+      Saucy::Configuration.notify("some_event", "some_data")
+      observer.should have_received("some_event").with("some_data")
+    end
+  end
+
+  it "can assign a manager email address" do
+    old_address = subject.manager_email_address
+    begin
+      subject.manager_email_address = 'newsender@example.com'
+      subject.manager_email_address.should == 'newsender@example.com'
+    ensure
+      subject.manager_email_address = old_address
+    end
+  end
+
+  it "can assign a support email address" do
+    old_address = subject.support_email_address
+    begin
+      subject.support_email_address = 'newsender@example.com'
+      subject.support_email_address.should == 'newsender@example.com'
+    ensure
+      subject.support_email_address = old_address
+    end
+  end
+
+  def cleanup_observers
+    yield
+  ensure
+    subject.observers.clear
+  end
+end

data/spec/scaffold/config/routes.rb

@@ -0,0 +1,5 @@
+Rails.application.routes.draw do
+  match "sign_in"  => "application#index", :as => "sign_in"
+  root :to => "application#index"
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,39 @@
+# This file is copied to spec/ when you run 'rails generate rspec:install'
+ENV["RAILS_ENV"] ||= 'test'
+
+if File.exist?("config/environment.rb")
+  require "config/environment"
+else
+  require File.expand_path("../environment", __FILE__)
+end
+
+require 'rspec/rails'
+require 'shoulda'
+require 'timecop'
+
+# Requires supporting ruby files with custom matchers and macros, etc,
+# in spec/support/ and its subdirectories.
+Dir[Rails.root.join("spec/support/**/*.rb")].each {|f| require f}
+
+RSpec.configure do |config|
+  # == Mock Framework
+  #
+  # If you prefer to use mocha, flexmock or RR, uncomment the appropriate line:
+  #
+  # config.mock_with :mocha
+  # config.mock_with :flexmock
+  # config.mock_with :rr
+  config.mock_with :mocha
+
+  # 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
+
+  config.backtrace_clean_patterns << %r{gems/}
+
+  config.include AuthenticationHelpers
+end

data/spec/support/authentication_helpers.rb

@@ -0,0 +1,81 @@
+module AuthenticationHelpers
+  def sign_in_as(user)
+    controller.current_user = user
+  end
+
+  def sign_in
+    sign_in_as(Factory(:user))
+  end
+
+  def sign_out
+    controller.current_user = nil
+  end
+
+  def current_user
+    controller.current_user
+  end
+
+  def signed_in?
+    controller.signed_in?
+  end
+
+  def sign_in_as_admin_of_account(account)
+    user = Factory(:user)
+    Factory(:membership, :user => user, :account => account, :admin => true)
+    sign_in_as user
+  end
+
+  def sign_in_as_non_admin_of_account(account)
+    user = Factory(:user)
+    Factory(:membership, :user => user, :account => account, :admin => false)
+    sign_in_as user
+  end
+
+  def sign_in_as_non_admin_of_project(project)
+    user = Factory(:user)
+    membership = Factory(:membership, :user    => user,
+                                                      :account => account,
+                                                      :admin   => false)
+    Factory(:permission, :membership => membership,
+                                 :project            => project)
+    sign_in_as user
+  end
+
+  def sign_in_as_admin_of_project(project)
+    user = Factory(:user)
+    membership = Factory(:membership, :user    => user,
+                                                      :account => account,
+                                                      :admin   => true)
+    Factory(:permission, :membership => membership,
+                                 :project            => project)
+    sign_in_as user
+  end
+end
+
+RSpec::Matchers.define :be_signed_in do
+  match do |controller|
+    @controller = controller
+    @controller.signed_in? &&
+      (@expected_user.nil? || @expected_user == @controller.current_user)
+  end
+
+  chain :as do |user|
+    @expected_user = user
+  end
+
+  failure_message_for_should do
+    message = "expected to be signed in"
+    message << " as #{@expected_user.inspect}" if @expected_user
+    message << " but was "
+    if @controller.signed_in?
+      message << "signed in as #{@controller.current_user.inspect}"
+    else
+      message << "not signed in"
+    end
+    message
+  end
+
+  failure_message_for_should_not do
+    "didn't expect to be signed in"
+  end
+end

data/spec/support/authorization_helpers.rb

@@ -0,0 +1,56 @@
+module AuthorizationHelpers
+  module AccountAdminExampleGroup
+    extend ActiveSupport::Concern
+    included do
+      let(:account) { Factory(:account) }
+      before { sign_in_as_admin_of_account(account) }
+    end
+  end
+
+  module AccountMemberExampleGroup
+    extend ActiveSupport::Concern
+    included do
+      let(:account) { Factory(:account) }
+      before { sign_in_as_non_admin_of_account(account) }
+    end
+  end
+
+  module ProjectAdminExampleGroup
+    extend ActiveSupport::Concern
+    included do
+      let(:account) { Factory(:account) }
+      let(:project) { Factory(:project, :account => account) }
+      before { sign_in_as_admin_of_project(project) }
+    end
+  end
+
+  module ProjectMemberExampleGroup
+    extend ActiveSupport::Concern
+    included do
+      let(:account) { Factory(:account) }
+      let(:project) { Factory(:project, :account => account) }
+      before { sign_in_as_non_admin_of_project(project) }
+    end
+  end
+
+  module UserExampleGroup
+    extend ActiveSupport::Concern
+    included do
+      let(:user) { Factory(:user) }
+      before { sign_in_as(user) }
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include AuthorizationHelpers::AccountAdminExampleGroup,
+    :as => :account_admin
+  config.include AuthorizationHelpers::AccountMemberExampleGroup,
+    :as => :account_member
+  config.include AuthorizationHelpers::ProjectAdminExampleGroup,
+    :as => :project_admin
+  config.include AuthorizationHelpers::ProjectMemberExampleGroup,
+    :as => :project_member
+  config.include AuthorizationHelpers::UserExampleGroup,
+    :as => :user
+end

data/spec/support/braintree.rb

@@ -0,0 +1,7 @@
+require 'saucy/fake_braintree'
+
+Braintree::Configuration.logger = Logger.new("tmp/log")
+
+RSpec.configure do |config|
+  config.after(:each) { FakeBraintree.clear! }
+end

data/spec/support/clearance_matchers.rb

@@ -0,0 +1,55 @@
+module ClearanceMatchers
+  class DenyAccessMatcher
+    include Shoulda::ActionController::Matchers
+
+    def initialize(context)
+      @context = context
+    end
+
+    def matches?(controller)
+      if @method
+        @context.__send__(@method, *@args)
+      end
+
+      begin
+        if @flash
+          controller.should set_the_flash.to(@flash)
+        else
+          controller.should_not set_the_flash
+        end
+
+        url = controller.__send__(:sign_in_url)
+        controller.should redirect_to(url).in_context(@context)
+
+        true
+      rescue RSpec::Expectations::ExpectationNotMetError => failure
+        @failure_message = failure.message
+        false
+      end
+    end
+
+    def flash(flash)
+      @flash = flash
+      self
+    end
+
+    def on(method, *args)
+      @method = method
+      @args   = args
+      self
+    end
+
+    def failure_message_for_should
+      @failure_message
+    end
+  end
+
+  def deny_access
+    DenyAccessMatcher.new(self)
+  end
+end
+
+
+RSpec.configure do |config|
+  config.include ClearanceMatchers
+end

data/spec/support/notifications.rb

@@ -0,0 +1,57 @@
+class RecordedEvent
+  attr_reader :name, :data
+
+  def initialize(name, data)
+    @name = name.to_s
+    @data = data
+  end
+
+  def inspect
+    "<Event:#{name} #{inspect_data}>"
+  end
+
+  def ==(other)
+    name == other.name && data == other.data
+  end
+
+  private
+
+  def inspect_data
+    data.inject([]) { |result, (key, value)|
+      result << "#{key.inspect} => #{value.inspect.slice(0, 20)}"
+    }.join(", ")
+  end
+end
+
+class RecordingObserver
+  attr_reader :events
+
+  def initialize
+    @events = []
+  end
+
+  def method_missing(name, data)
+    @events << RecordedEvent.new(name, data)
+  end
+end
+
+RSpec::Matchers.define :notify_observers do |event_name, data|
+  match do |ignored_subject|
+    @event = RecordedEvent.new(event_name, data)
+    recorder.events.should include(@event)
+  end
+
+  failure_message do
+    "Expected event:\n#{@event.inspect}\n\nGot events:\n#{recorder.events.map(&:inspect).join("\n")}"
+  end
+
+  def recorder
+    Saucy::Configuration.observers.last
+  end
+end
+
+RSpec.configure do |config|
+  config.before do
+    Saucy::Configuration.observers = [RecordingObserver.new]
+  end
+end