saucy 0.1.3 → 0.1.4

data/lib/saucy/account.rb

@@ -3,12 +3,12 @@ module Saucy
     extend ActiveSupport::Concern
 
     included do
-      has_many :account_memberships, :dependent => :destroy
-      has_many :users, :through => :account_memberships
+      has_many :memberships, :dependent => :destroy
+      has_many :users, :through => :memberships
       has_many :projects, :dependent => :destroy
-      has_many :admins, :through    => :account_memberships,
+      has_many :admins, :through    => :memberships,
                         :source     => :user,
-                        :conditions => { 'account_memberships.admin' => true }
+                        :conditions => { 'memberships.admin' => true }
 
       belongs_to :plan
 
@@ -31,7 +31,7 @@ module Saucy
       end
 
       def has_member?(user)
-        account_memberships.exists?(:user_id => user.id)
+        memberships.exists?(:user_id => user.id)
       end
 
       def users_by_name
@@ -45,6 +45,10 @@ module Saucy
       def projects_visible_to(user)
         projects.visible_to(user)
       end
+
+      def memberships_by_name
+        memberships.by_name
+      end
     end
   end
 end

data/lib/saucy/project.rb

@@ -4,12 +4,19 @@ module Saucy
 
     included do
       belongs_to :account
-      has_many :project_memberships, :dependent => :destroy
-      has_many :users, :through => :project_memberships
+      has_many :permissions, :dependent => :destroy
+      has_many :users, :through => :permissions
 
       validates_presence_of :account_id
 
       after_create :assign_default_memberships
+      after_save :update_memberships
+
+      # We have to define this here instead of mixing it in,
+      # because ActiveRecord does the same
+      def user_ids=(new_user_ids)
+        @new_user_ids = new_user_ids.reject { |user_id| user_id.blank? }
+      end
     end
 
     module ClassMethods
@@ -24,14 +31,30 @@ module Saucy
 
     module InstanceMethods
       def has_member?(user)
-        project_memberships.exists?(:user_id => user.id)
+        permissions.
+          joins(:membership).
+          exists?(:memberships => { :user_id => user.id })
       end
 
       private
 
       def assign_default_memberships
-        account.admins.each do |admin|
-          self.project_memberships.create(:user => admin)
+        account.memberships.where(:admin => true).each do |membership|
+          self.permissions.create(:membership => membership)
+        end
+      end
+
+      def update_memberships
+        if @new_user_ids
+          removed_user_ids = self.user_ids - @new_user_ids
+          added_user_ids = @new_user_ids - self.user_ids
+
+          permissions.where(:user_id => removed_user_ids).destroy_all
+          added_user_ids.each do |added_user_id|
+            membership =
+              account.memberships.where(:user_id => added_user_id).first
+            permissions.create!(:membership => membership)
+          end
         end
       end
     end

data/lib/saucy/user.rb

@@ -4,28 +4,21 @@ module Saucy
 
     included do
       attr_accessible :name, :project_ids, :email, :password_confirmation, :password
-      has_many :project_memberships
-      has_many :projects, :through => :project_memberships
-      has_many :account_memberships
-      has_many :accounts, :through => :account_memberships
+      has_many :memberships
+      has_many :accounts, :through => :memberships
+      has_many :permissions
+      has_many :projects, :through => :permissions
       validates_presence_of :name
     end
 
     module InstanceMethods
       def admin_of?(account)
-        account_memberships.exists?(:account_id => account.id, :admin => true)
+        memberships.exists?(:account_id => account.id, :admin => true)
       end
 
       def member_of?(account_or_project)
         account_or_project.has_member?(self)
       end
-
-      def update_permissions_for(account, project_ids)
-        project_ids_for_other_accounts = projects.
-          reject { |project| project.account_id == account.id }.
-          map { |project| project.id }
-        self.project_ids = project_ids + project_ids_for_other_accounts
-      end
     end
 
     module ClassMethods

data/spec/controllers/memberships_controller_spec.rb

@@ -3,20 +3,30 @@ require 'spec_helper'
 describe MembershipsController, "routes" do
   it { should route(:get, "/accounts/abc/memberships").
                 to(:action => :index, :account_id => 'abc') }
+  it { should route(:get, "/memberships/abc/edit").
+                to(:action => :edit, :id => 'abc') }
+  it { should route(:put, "/memberships/abc").
+                to(:action => :update, :id => 'abc') }
+  it { should route(:delete, "/memberships/abc").
+                to(:action => :destroy, :id => 'abc') }
 end
 
 describe MembershipsController, "permissions", :as => :account_member do
+  let(:membership) { Factory(:membership, :account => account) }
   it { should deny_access.
                 on(:get, :index, :account_id => account.to_param).
                 flash(/admin/) }
+  it { should deny_access.
+                on(:get, :edit, :id => membership.to_param).
+                flash(/admin/) }
 end
 
 describe MembershipsController, "index", :as => :account_admin do
-  let(:users) { [Factory.stub(:user), Factory.stub(:user)] }
+  let(:memberships) { [Factory.stub(:membership), Factory.stub(:membership)] }
 
   before do
     Account.stubs(:find_by_url! => account)
-    account.stubs(:users_by_name => users)
+    account.stubs(:memberships_by_name => memberships)
     get :index, :account_id => account.to_param
   end
 
@@ -25,9 +35,81 @@ describe MembershipsController, "index", :as => :account_admin do
     should render_template(:index)
   end
 
-  it "assigns users by name" do
-    account.should have_received(:users_by_name)
-    should assign_to(:users).with(users)
+  it "assigns memberships by name" do
+    account.should have_received(:memberships_by_name)
+    should assign_to(:memberships).with(memberships)
+  end
+end
+
+describe MembershipsController, "edit", :as => :account_admin do
+  let(:edited_membership) { Factory.stub(:membership, :account => account) }
+  let(:projects) { [Factory.stub(:project)] }
+
+  before do
+    Membership.stubs(:find => edited_membership)
+    account.stubs(:projects_by_name => projects)
+    get :edit, :id => edited_membership.to_param
+  end
+
+  it "renders the edit template" do
+    should respond_with(:success)
+    should render_template(:edit)
+  end
+
+  it "assigns projects by name" do
+    account.should have_received(:projects_by_name)
+    should assign_to(:projects).with(projects)
+  end
+
+  it "assigns the membership being edited" do
+    Membership.should have_received(:find).with(edited_membership.to_param,
+                                                :include => :account)
+    should assign_to(:membership).with(edited_membership)
   end
 end
 
+describe MembershipsController, "update", :as => :account_admin do
+  let(:edited_membership) { Factory.stub(:membership, :account => account) }
+  let(:attributes) { 'some attributes' }
+
+  before do
+    Membership.stubs(:find => edited_membership)
+    edited_membership.stubs(:update_attributes!)
+    put :update, :id         => edited_membership.to_param,
+                 :membership => attributes
+  end
+
+  it "redirects to the account memberships index" do
+    should redirect_to(account_memberships_url(account))
+  end
+
+  it "update the membership" do
+    edited_membership.should have_received(:update_attributes!).with(attributes)
+  end
+
+  it "sets a flash message" do
+    should set_the_flash.to(/update/i)
+  end
+end
+
+describe MembershipsController, "destroy", :as => :account_admin do
+  let(:removed_membership) { Factory.stub(:membership, :account => account) }
+
+  before do
+    Membership.stubs(:find => removed_membership)
+    removed_membership.stubs(:destroy)
+    delete :destroy, :id => removed_membership.to_param
+  end
+
+  it "redirects to the account memberships index" do
+    should redirect_to(account_memberships_url(account))
+  end
+
+  it "removes the membership" do
+    removed_membership.should have_received(:destroy)
+  end
+
+  it "sets a flash message" do
+    should set_the_flash.to(/remove/i)
+  end
+end

data/spec/environment.rb

@@ -0,0 +1,91 @@
+PROJECT_ROOT = File.expand_path("../..", __FILE__)
+$LOAD_PATH << File.join(PROJECT_ROOT, "lib")
+
+require 'rails/all'
+require 'saucy'
+require 'clearance'
+require 'factory_girl'
+require 'bourne'
+
+class ApplicationController < ActionController::Base
+  include Clearance::Authentication
+  include Saucy::AccountAuthorization
+end
+
+class ProjectsController < ApplicationController
+  include Saucy::ProjectsController
+end
+
+class User < ActiveRecord::Base
+  include Clearance::User
+  include Saucy::User
+end
+
+module Testapp
+  class Application < Rails::Application
+    config.action_mailer.default_url_options = { :host => 'localhost' }
+    config.encoding = "utf-8"
+    config.paths.config.database = "spec/scaffold/config/database.yml"
+    config.paths.app.models << "lib/generators/saucy/install/templates/models"
+    config.paths.config.routes << "spec/scaffold/config/routes.rb"
+    config.paths.app.views << "spec/scaffold/views"
+    config.paths.log = "tmp/log"
+    config.cache_classes = true
+    config.whiny_nils = true
+    config.consider_all_requests_local = true
+    config.action_controller.perform_caching = false
+    config.action_dispatch.show_exceptions = false
+    config.action_controller.allow_forgery_protection = false
+    config.action_mailer.delivery_method = :test
+    config.active_support.deprecation = :stderr
+  end
+end
+
+Testapp::Application.initialize!
+
+require "lib/generators/saucy/features/templates/factories"
+require "lib/generators/saucy/install/templates/create_saucy_tables"
+
+class ClearanceCreateUsers < ActiveRecord::Migration
+  def self.up
+    create_table(:users) do |t|
+      t.string   :email
+      t.string   :encrypted_password, :limit => 128
+      t.string   :salt,               :limit => 128
+      t.string   :confirmation_token, :limit => 128
+      t.string   :remember_token,     :limit => 128
+      t.boolean  :email_confirmed, :default => false, :null => false
+      t.timestamps
+    end
+
+    add_index :users, :email
+    add_index :users, :remember_token
+  end
+end
+
+class ClearanceMailer
+  def self.change_password(user)
+    new
+  end
+
+  def self.confirmation(user)
+    new
+  end
+
+  def self.deliver_change_password(user)
+  end
+
+  def self.deliver_confirmation(user)
+  end
+
+  def deliver
+  end
+end
+
+Clearance.configure do |config|
+end
+
+FileUtils.rm_f(File.join(PROJECT_ROOT, 'tmp', 'test.sqlite3'))
+ClearanceCreateUsers.suppress_messages { ClearanceCreateUsers.migrate(:up) }
+CreateSaucyTables.suppress_messages { CreateSaucyTables.migrate(:up) }
+

data/spec/models/account_spec.rb

@@ -3,8 +3,8 @@ require 'spec_helper'
 describe Account do
   subject { Factory(:account) }
 
-  it { should have_many(:account_memberships) }
-  it { should have_many(:users).through(:account_memberships) }
+  it { should have_many(:memberships) }
+  it { should have_many(:users).through(:memberships) }
   it { should have_many(:projects) }
 
   it { should validate_uniqueness_of(:name) }
@@ -39,9 +39,9 @@ describe Account do
     non_admin = Factory(:user)
     non_member = Factory(:user)
     admins.each do |admin|
-      Factory(:account_membership, :user => admin, :account => subject, :admin => true)
+      Factory(:membership, :user => admin, :account => subject, :admin => true)
     end
-    Factory(:account_membership, :user => non_admin, :account => subject, :admin => false)
+    Factory(:membership, :user => non_admin, :account => subject, :admin => false)
 
     result = subject.admins
 
@@ -49,13 +49,24 @@ describe Account do
   end
 
   it "has a member with a membership" do
-    membership = Factory(:account_membership, :account => subject)
+    membership = Factory(:membership, :account => subject)
     should have_member(membership.user)
   end
 
   it "doesn't have a member without a membership" do
-    membership = Factory(:account_membership, :account => subject)
+    membership = Factory(:membership, :account => subject)
     should_not have_member(Factory(:user))
   end
+
+  it "finds memberships by name" do
+    expected = 'expected result'
+    memberships = stub('memberships', :by_name => expected)
+    account = Factory.stub(:account)
+    account.stubs(:memberships => memberships)
+
+    result = account.memberships_by_name
+
+    result.should == expected
+  end
 end
 

data/spec/models/membership_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Membership do
+  it { should belong_to(:account) }
+  it { should belong_to(:user) }
+  it { should validate_presence_of(:account_id) }
+  it { should validate_presence_of(:user_id) }
+  it { should have_many(:permissions) }
+  it { should have_many(:projects).through(:permissions) }
+
+  describe "given an existing account membership" do
+    before { Factory(:membership) }
+    it { should validate_uniqueness_of(:user_id).scoped_to(:account_id) }
+  end
+
+  it "delegates the user's name" do
+    user = Factory(:user)
+    membership = Factory(:membership, :user => user)
+
+    membership.name.should == user.name
+  end
+
+  it "delegates the user's email" do
+    user = Factory(:user)
+    membership = Factory(:membership, :user => user)
+
+    membership.email.should == user.email
+  end
+
+  it "returns memberships by name" do
+    Factory(:membership, :user => Factory(:user, :name => "def"))
+    Factory(:membership, :user => Factory(:user, :name => "abc"))
+    Factory(:membership, :user => Factory(:user, :name => "ghi"))
+
+    Membership.by_name.map(&:name).should == %w(abc def ghi)
+  end
+end

data/spec/models/permission_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Permission do
+  it { should belong_to(:project) }
+  it { should belong_to(:membership) }
+  it { should belong_to(:user) }
+
+  it "caches the user from the account membership" do
+    membership = Factory(:membership)
+    permission = Factory(:permission,
+                                 :membership => membership)
+    permission.user_id.should == membership.user_id
+  end
+
+  it "doesn't allow the user to be assigned" do
+    expect { subject.user = Factory.build(:user) }.to raise_error
+  end
+end
+

data/spec/models/project_spec.rb

@@ -3,18 +3,19 @@ require 'spec_helper'
 describe Project do
   it { should belong_to(:account) }
   it { should validate_presence_of(:account_id) }
-  it { should have_many(:project_memberships) }
-  it { should have_many(:users) }
+  it { should have_many(:permissions) }
+  it { should have_many(:users).through(:permissions) }
 
   it "finds projects visible to a user" do
     account = Factory(:account)
     user = Factory(:user)
-    Factory(:account_membership, :user => user, :account => account)
+    membership = Factory(:membership, :user => user, :account => account)
     visible_projects = [Factory(:project, :account => account),
                         Factory(:project, :account => account)]
     invisible_project = Factory(:project, :account => account)
     visible_projects.each do |visible_project|
-      Factory(:project_membership, :project => visible_project, :user => user)
+      Factory(:permission, :project            => visible_project,
+                                   :membership => membership)
     end
 
     Project.visible_to(user).to_a.should =~ visible_projects
@@ -38,12 +39,12 @@ describe Project, "for an account with admin and non-admin users" do
   subject              { Factory(:project, :account => account) }
 
   before do
-    Factory(:account_membership, :account => account, :user => non_admin, :admin => false)
-    Factory(:account_membership, :account => other_account,
+    Factory(:membership, :account => account, :user => non_admin, :admin => false)
+    Factory(:membership, :account => other_account,
                                  :user    => non_member,
                                  :admin   => true)
     admins.each do |admin|
-      Factory(:account_membership, :user => admin, :account => account, :admin => true)
+      Factory(:membership, :user => admin, :account => account, :admin => true)
     end
   end
 
@@ -68,8 +69,10 @@ describe Project, "saved" do
 
   it "has a member with a membership" do
     user = Factory(:user)
-    Factory(:account_membership, :account => subject.account, :user => user)
-    membership = Factory(:project_membership, :project => subject, :user => user)
+    membership = Factory(:membership, :account => subject.account,
+                                                      :user    => user)
+    membership = Factory(:permission, :project            => subject,
+                                              :membership => membership)
     should have_member(user)
   end
 
@@ -78,3 +81,30 @@ describe Project, "saved" do
     should_not have_member(user)
   end
 end
+
+describe Project, "assigning a new user list" do
+  subject { Factory(:project) }
+
+  let(:account) { subject.account }
+  let!(:member) { Factory(:user) }
+  let!(:non_member) { Factory(:user) }
+
+  before do
+    member_membership =
+      Factory(:membership, :account => account, :user => member)
+    non_member_membership =
+      Factory(:membership, :account => account, :user => non_member)
+    Factory(:permission, :membership => member_membership,
+                                 :project            => subject)
+
+    subject.reload.update_attributes!(:user_ids => [non_member.id, ""])
+  end
+
+  it "adds an added user" do
+    member.should_not be_member_of(subject)
+  end
+
+  it "removes a removed user" do
+    non_member.should be_member_of(subject)
+  end
+end