saucy 0.1.1

data/spec/layouts_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Saucy::Layouts do
+  it "allows a layout to be assigned" do
+    subject.accounts.index = "custom"
+    subject.accounts.index.should == "custom"
+  end
+
+  it "defaults to the application layout" do
+    subject.accounts.index.should == "application"
+  end
+
+  it "selects a layout for a controller" do
+    controller = AccountsController.new
+    controller.stubs(:action_name => 'index')
+    block = subject.class.to_proc
+
+    block.call(controller).should == 'application'
+  end
+end
+

data/spec/models/account_membership_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe AccountMembership 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) }
+
+  describe "given an existing account membership" do
+    before { Factory(:account_membership) }
+    it { should validate_uniqueness_of(:user_id).scoped_to(:account_id) }
+  end
+end

data/spec/models/account_spec.rb

@@ -0,0 +1,61 @@
+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(:projects) }
+
+  it { should validate_uniqueness_of(:name) }
+  it { should validate_uniqueness_of(:url) }
+  it { should validate_presence_of(  :name) }
+  it { should validate_presence_of(:url) }
+
+  it { should_not allow_mass_assignment_of(:id) }
+  it { should_not allow_mass_assignment_of(:updated_at) }
+  it { should_not allow_mass_assignment_of(:created_at) }
+  it { should allow_mass_assignment_of(:url) }
+
+  [nil, "", "a b", "a.b", "a%b"].each do |value|
+    it { should_not allow_value(value).for(:url).with_message(/letters/i) }
+  end
+
+  ["admin", "blog", "dev", "ftp", "mail", "pop", "pop3", "imap", "smtp",
+    "staging", "stats", "status","www"].each do |value|
+    it { should_not allow_value(value).for(:url).with_message(/reserved/i) }
+  end
+
+  ["foo", "f00", "37signals"].each do |value|
+    it { should allow_value(value).for(:url) }
+  end
+
+  it "should give its url for to_param" do
+    subject.to_param.should == subject.url
+  end
+
+  it "finds admin users" do
+    admins = [Factory(:user), Factory(:user)]
+    non_admin = Factory(:user)
+    non_member = Factory(:user)
+    admins.each do |admin|
+      Factory(:account_membership, :user => admin, :account => subject, :admin => true)
+    end
+    Factory(:account_membership, :user => non_admin, :account => subject, :admin => false)
+
+    result = subject.admins
+
+    result.to_a.should =~ admins
+  end
+
+  it "has a member with a membership" do
+    membership = Factory(:account_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)
+    should_not have_member(Factory(:user))
+  end
+end
+

data/spec/models/invitation_spec.rb

@@ -0,0 +1,160 @@
+require 'spec_helper'
+
+describe Invitation do
+  it { should validate_presence_of(:account_id) }
+  it { should validate_presence_of(:email) }
+  it { should belong_to(:account) }
+  it { should_not allow_mass_assignment_of(:account_id) }
+
+  %w(new_user_name new_user_email new_user_password
+     new_user_password_confirmation existing_user_password).each do |attribute|
+    it "allows assignment of #{attribute}" do
+      should respond_to(attribute)
+      should respond_to(:"#{attribute}=")
+    end
+  end
+end
+
+describe Invitation, "saved" do
+  let(:mail)    { stub('invitation', :deliver => true) }
+  before        { InvitationMailer.stubs(:invitation => mail) }
+  subject       { Factory(:invitation) }
+  let(:email)   { subject.email }
+
+  it "sends an invitation email" do
+    InvitationMailer.should have_received(:invitation).with(subject)
+    mail.should have_received(:deliver)
+  end
+
+  it "delegates account name" do
+    subject.account_name.should == subject.account.name
+  end
+
+  it "defauls new user email to invited email" do
+    subject.new_user_email.should == subject.email
+  end
+
+  it "defauls existing user email to invited email" do
+    subject.existing_user_email.should == subject.email
+  end
+end
+
+describe Invitation, "valid accept for a new user" do
+  let(:password) { 'secret' }
+  let(:name)     { 'Rocket' }
+  subject { Factory(:invitation) }
+
+  let!(:result) do
+    subject.accept(:new_user_password              => password,
+                   :new_user_password_confirmation => password,
+                   :new_user_name                  => name)
+  end
+
+  let(:user) { subject.user }
+  let(:account) { subject.account }
+
+  it "returns true" do
+    result.should be_true
+  end
+
+  it "creates a saved, confirmed user" do
+    user.should_not be_nil
+    user.should be_persisted
+    user.should be_email_confirmed
+    user.name.should == name
+  end
+
+  it "adds the user to the account" do
+    account.users.should include(user)
+  end
+end
+
+describe Invitation, "invalid accept for a new user" do
+  subject { Factory(:invitation) }
+  let!(:result) { subject.accept({}) }
+  let(:user) { subject.user }
+  let(:account) { subject.account }
+
+  it "returns false" do
+    result.should be_false
+  end
+
+  it "doesn't create a user" do
+    user.should be_new_record
+  end
+
+  it "adds error messages" do
+    subject.errors[:new_user_password].should be_present
+  end
+end
+
+describe Invitation, "valid accept for an existing user" do
+  let(:password) { 'secret' }
+  let(:user)     { Factory(:email_confirmed_user,
+                           :password              => password,
+                           :password_confirmation => password) }
+  subject        { Factory(:invitation, :email => user.email) }
+  let(:account)  { subject.account }
+
+  let!(:result) do
+    subject.accept(:existing_user_password => password)
+  end
+
+  it "returns true" do
+    result.should be_true
+  end
+
+  it "adds the user to the account" do
+    account.users.should include(user)
+  end
+end
+
+describe Invitation, "accepting with an invalid password" do
+  let(:user)    { Factory(:email_confirmed_user) }
+  subject       { Factory(:invitation, :email => user.email) }
+  let(:account) { subject.account }
+  let!(:result) { subject.accept(:existing_user_password => 'wrong') }
+
+  it "adds error messages" do
+    subject.errors[:existing_user_password].should be_present
+  end
+
+  it "doesn't add the user to the account" do
+    subject.account.users.should_not include(subject.user)
+  end
+
+  it "returns false" do
+    result.should be_false
+  end
+end
+
+describe Invitation, "accepting with an unknown email" do
+  subject       { Factory(:invitation, :email => 'unknown') }
+  let(:account) { subject.account }
+  let!(:result) { subject.accept(:existing_user_password => 'secret') }
+
+  it "adds error messages" do
+    subject.errors[:existing_user_email].should be_present
+  end
+
+  it "returns false" do
+    result.should be_false
+  end
+end
+
+describe Invitation, "accepting an admin invite" do
+  let(:password) { 'secret' }
+  let(:user)     { Factory(:email_confirmed_user,
+                           :password              => password,
+                           :password_confirmation => password) }
+  subject        { Factory(:invitation, :email => user.email, :admin => true) }
+  let(:account)  { subject.account }
+
+  let!(:result) do
+    subject.accept(:existing_user_password => password)
+  end
+
+  it "adds the user as an admin" do
+    user.should be_admin_of(account)
+  end
+end

data/spec/models/project_membership_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe ProjectMembership do
+  it { should allow_mass_assignment_of(:user_id) }
+  it { should allow_mass_assignment_of(:user) }
+  it { should_not allow_mass_assignment_of(:updated_at) }
+  it { should_not allow_mass_assignment_of(:created_at) }
+  it { should belong_to(:project) }
+  it { should belong_to(:user) }
+end
+
+describe ProjectMembership, "for a user that isn't an account member" do
+  let!(:account)       { Factory(:account) }
+  let!(:other_account) { Factory(:account) }
+  let!(:project)       { Factory(:project, :account => account) }
+  let!(:user)          { Factory(:user) }
+  subject              { Factory.build(:project_membership, :project => project,
+                                                            :user    => user) }
+
+  before { Factory(:account_membership, :user => user, :account => other_account) }
+
+  it "isn't valid" do
+    should_not be_valid
+    subject.errors[:base].first.should =~ /account/i
+  end
+end

data/spec/models/project_spec.rb

@@ -0,0 +1,80 @@
+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 "finds projects visible to a user" do
+    account = Factory(:account)
+    user = Factory(:user)
+    Factory(:account_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)
+    end
+
+    Project.visible_to(user).to_a.should =~ visible_projects
+  end
+
+  it "returns projects by name" do
+    Factory(:project, :name => "def")
+    Factory(:project, :name => "abc")
+    Factory(:project, :name => "ghi")
+
+    Project.by_name.map(&:name).should == %w(abc def ghi)
+  end
+end
+
+describe Project, "for an account with admin and non-admin users" do
+  let!(:account)       { Factory(:account, :name => "Account") }
+  let!(:other_account) { Factory(:account, :name => "Other") }
+  let!(:non_admin)     { Factory(:user) }
+  let!(:admins)        { [Factory(:user), Factory(:user)] }
+  let!(:non_member)    { Factory(:user) }
+  subject              { Factory(:project, :account => account) }
+
+  before do
+    Factory(:account_membership, :account => account, :user => non_admin, :admin => false)
+    Factory(:account_membership, :account => other_account,
+                                 :user    => non_member,
+                                 :admin   => true)
+    admins.each do |admin|
+      Factory(:account_membership, :user => admin, :account => account, :admin => true)
+    end
+  end
+
+  it "has users" do
+    subject.users.should_not be_empty
+  end
+
+  it "is viewable by admins by default" do
+    admins.each do |admin|
+      should have_member(admin)
+    end
+  end
+
+  it "isn't viewable by non-members" do
+    should_not have_member(non_admin)
+    should_not have_member(non_member)
+  end
+end
+
+describe Project, "saved" do
+  subject { Factory(:project) }
+
+  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)
+    should have_member(user)
+  end
+
+  it "doesn't have a member without a membership" do
+    user = Factory(:user)
+    should_not have_member(user)
+  end
+end

data/spec/models/signup_spec.rb

@@ -0,0 +1,175 @@
+require 'spec_helper'
+
+describe Signup do
+  it "complies with the activemodel api" do
+    subject.class.should be_kind_of(ActiveModel::Naming)
+    should_not be_persisted
+    should be_kind_of(ActiveModel::Conversion)
+    should be_kind_of(ActiveModel::Validations)
+  end
+end
+
+describe Signup, "with attributes in the constructor" do
+  subject { Signup.new(:user_name => 'Joe', :account_name => 'blokes', :url => 'blk') }
+  it "assigns attributes" do
+    subject.user_name.should == 'Joe'
+    subject.account_name.should == 'blokes'
+    subject.url.should == 'blk'
+  end
+end
+
+share_examples_for "invalid signup" do
+  before { @previous_user_count = User.count }
+
+  it "returns false" do
+    @result.should be_false
+  end
+
+  it "doesn't create a user" do
+    User.count.should == @previous_user_count
+  end
+
+  it "doesn't create an account" do
+    subject.account.should be_new_record
+  end
+end
+
+share_examples_for "valid signup" do
+  it "returns true" do
+    @result.should be_true
+  end
+
+  it "saves the account" do
+    subject.account.should be_persisted
+  end
+end
+
+describe Signup, "with a valid user and account" do
+  it_should_behave_like "valid signup"
+  let(:email) { "user@example.com" }
+  subject { Factory.build(:signup, :email => email) }
+
+  before do
+    @result = subject.save
+  end
+
+  it "saves the user" do
+    subject.user.should be_persisted
+  end
+
+  it "assigns the user to the account" do
+    subject.user.reload.accounts.should include(subject.account)
+  end
+
+  it "creates an admin user" do
+    subject.user.should be_admin_of(subject.account)
+  end
+end
+
+describe Signup, "with a valid user but invalid account" do
+  it_should_behave_like "invalid signup"
+  subject { Factory.build(:signup, :account_name => "") }
+
+  before do
+    @result = subject.save
+  end
+
+  it "adds error messages" do
+    subject.errors[:account_name].should_not be_empty
+  end
+end
+
+describe Signup, "with an invalid user but valid account" do
+  subject { Factory.build(:signup, :user_name => nil) }
+  it_should_behave_like "invalid signup"
+
+  before do
+    @result = subject.save
+  end
+
+  it "adds error messages" do
+    subject.errors[:user_name].should_not be_empty
+  end
+end
+
+describe Signup, "with an invalid user and nvalid account" do
+  subject { Factory.build(:signup, :user_name => nil, :account_name => nil) }
+  it_should_behave_like "invalid signup"
+
+  before do
+    @result = subject.save
+  end
+
+  it "adds error messages for both" do
+    subject.errors[:user_name].should_not be_empty
+    subject.errors[:account_name].should_not be_empty
+  end
+end
+
+describe Signup, "valid with an existing user and correct password" do
+  it_should_behave_like "valid signup"
+  let(:email) { "user@example.com" }
+  let(:password) { "test" }
+  let!(:user) { Factory(:user, :email                 => email,
+                               :password              => password,
+                               :password_confirmation => password) }
+  subject { Factory.build(:signup, :email => email, :password => password) }
+  before { @result = subject.save }
+
+  it "doesn't create a user" do
+    User.count.should == 1
+  end
+
+  it "assigns the user to the account as an admin" do
+    user.reload.accounts.should include(subject.account)
+    user.should be_admin_of(subject.account)
+  end
+end
+
+describe Signup, "valid with a signed in user" do
+  it_should_behave_like "valid signup"
+  let!(:user) { Factory(:user) }
+  subject { Factory.build(:signup, :user => user, :password => '') }
+  before { @result = subject.save }
+
+  it "doesn't create a user" do
+    User.count.should == 1
+  end
+
+  it "assigns the user to the account as an admin" do
+    user.reload.accounts.should include(subject.account)
+    user.should be_admin_of(subject.account)
+  end
+end
+
+describe Signup, "valid with an existing user and incorrect password" do
+  it_should_behave_like "invalid signup"
+  let(:email) { "user@example.com" }
+  let(:password) { "test" }
+  let!(:user) { Factory(:user, :email                 => email,
+                               :password              => password,
+                               :password_confirmation => password) }
+  subject { Factory.build(:signup, :email => email, :password => 'wrong') }
+  before { @result = subject.save }
+
+  it "adds error messages" do
+    subject.errors.full_messages.should include("Password is incorrect")
+  end
+end
+
+describe Signup, "invalid with an existing user and correct password" do
+  it_should_behave_like "invalid signup"
+  let(:email) { "user@example.com" }
+  let(:password) { "test" }
+  let!(:user) { Factory(:user, :email                 => email,
+                               :password              => password,
+                               :password_confirmation => password) }
+  subject { Factory.build(:signup, :account_name => '',
+                                   :email        => email,
+                                   :password     => password) }
+  before { @result = subject.save }
+
+  it "doesn't assign the user to the account" do
+    user.reload.accounts.should_not include(subject.account)
+  end
+end