saasy 0.0.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 saucy layout" do
+    subject.accounts.index.should == "saucy"
+  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 == 'saucy'
+  end
+end
+

data/spec/mailers/billing_mailer_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+describe "with an account and transaction" do
+  let(:account) { Factory(:paid_account) }
+
+  before do
+    subscription = FakeBraintree.subscriptions[account.subscription_token]
+    subscription["transactions"] = [FakeBraintree.generated_transaction]
+  end
+
+  describe BillingMailer, "receipt" do
+    subject { BillingMailer.receipt(account, account.subscription.transactions.first) }
+
+    it "sends the receipt mail from the support address" do
+      subject.from.should == [Saucy::Configuration.support_email_address]
+    end
+
+    it "sets the receipt mail reply-to to the support address" do
+      subject.reply_to.should == [Saucy::Configuration.support_email_address]
+    end
+  end
+
+  describe BillingMailer, "problem" do
+    subject { BillingMailer.problem(account, account.subscription.transactions.first) }
+
+    it "sends the problem mail from the support address" do
+      subject.from.should == [Saucy::Configuration.support_email_address]
+    end
+
+    it "sets the problem mail reply-to to the support address" do
+      subject.reply_to.should == [Saucy::Configuration.support_email_address]
+    end
+  end
+
+  describe BillingMailer, "expiring trial" do
+    subject { BillingMailer.expiring_trial(account) }
+
+    it "sends the expiring trial mail from the support address" do
+      subject.from.should == [Saucy::Configuration.manager_email_address]
+    end
+
+    it "sets the expiring trial mail reply-to to the support address" do
+      subject.reply_to.should == [Saucy::Configuration.support_email_address]
+    end
+  end
+
+  describe BillingMailer, "new unactivated" do
+    subject { BillingMailer.expiring_trial(account) }
+
+    it "sends the new unactivated mail from the support address" do
+      subject.from.should == [Saucy::Configuration.manager_email_address]
+    end
+
+    it "sets the new unactivated mail reply-to to the support address" do
+      subject.reply_to.should == [Saucy::Configuration.support_email_address]
+    end
+  end
+
+  describe BillingMailer, "completed trial" do
+    subject { BillingMailer.completed_trial(account) }
+
+    it "uses the completed trial notice" do
+      notice = I18n.translate!("billing_mailer.completed_trial.notice",
+                               :account_name => account.name)
+      subject.body.should include(notice)
+    end
+  end
+end

data/spec/mailers/invitiation_mailer_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe InvitationMailer, "invitation" do
+  let(:invitation) { Factory(:invitation) }
+  subject { InvitationMailer.invitation(invitation) }
+
+  it "sets reply-to to the user that sent the invitation" do
+    subject.reply_to.should == [invitation.sender_email]
+  end
+
+  it "sets from to the user's name" do
+    from = subject.header_fields.detect { |field| field.name == "From"}
+    from.value.should =~ %r{^"#{invitation.sender_name}" <.*>$}
+  end
+
+  it "sends from the support address" do
+    subject.from.should == [Saucy::Configuration.support_email_address]
+  end
+end

data/spec/models/account_spec.rb

@@ -0,0 +1,218 @@
+require 'spec_helper'
+
+describe Account do
+  subject { Factory(:account) }
+
+  it { should have_many(:memberships) }
+  it { should have_many(:users).through(:memberships) }
+  it { should have_many(:projects) }
+  it { should belong_to(:plan) }
+
+  it { should validate_uniqueness_of(:keyword) }
+  it { should validate_presence_of(  :name) }
+  it { should validate_presence_of(:keyword) }
+  it { should validate_presence_of(:plan_id) }
+
+  it { should allow_value("hello").for(:keyword) }
+  it { should allow_value("0123").for(:keyword) }
+  it { should allow_value("hello_world").for(:keyword) }
+  it { should allow_value("hello-world").for(:keyword) }
+  it { should_not allow_value("HELLO").for(:keyword) }
+  it { should_not allow_value("hello world").for(:keyword) }
+
+  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(:keyword) }
+
+  [nil, "", "a b", "a.b", "a%b"].each do |value|
+    it { should_not allow_value(value).for(:keyword).with_message(/letters/i) }
+  end
+
+  ["foo", "f00", "37signals"].each do |value|
+    it { should allow_value(value).for(:keyword) }
+  end
+
+  it "should give its keyword for to_param" do
+    subject.to_param.should == subject.keyword
+  end
+
+  it "finds admin users" do
+    admins = [Factory(:user), Factory(:user)]
+    non_admin = Factory(:user)
+    non_member = Factory(:user)
+    admins.each do |admin|
+      Factory(:membership, :user => admin, :account => subject, :admin => true)
+    end
+    Factory(:membership, :user => non_admin, :account => subject, :admin => false)
+
+    result = subject.admins
+
+    result.to_a.should =~ admins
+  end
+
+  it "finds non admin users" do
+    non_admins = [Factory(:user), Factory(:user)]
+    admin = Factory(:user)
+    non_member = Factory(:user)
+    non_admins.each do |non_admin|
+      Factory(:membership, :user => non_admin, :account => subject, :admin => false)
+    end
+    Factory(:membership, :user => admin, :account => subject, :admin => true)
+
+    result = subject.non_admins
+
+    result.to_a.should =~ non_admins
+  end
+
+  it "finds emails for admin users" do
+    admins = [Factory(:user), Factory(:user)]
+    non_admin = Factory(:user)
+    non_member = Factory(:user)
+    admins.each do |admin|
+      Factory(:membership, :user => admin, :account => subject, :admin => true)
+    end
+    Factory(:membership, :user => non_admin, :account => subject, :admin => false)
+
+    subject.admin_emails.should == admins.map(&:email)
+  end
+
+  it "has a member with a membership" do
+    membership = Factory(:membership, :account => subject)
+    should have_member(membership.user)
+  end
+
+  it "has a count of users" do
+    membership = Factory(:membership, :account => subject)
+    subject.users_count.should == 1
+  end
+
+  it "has a count of active projects" do
+    Factory(:project, :account => subject, :archived => false)
+    Factory(:project, :account => subject, :archived => true)
+    subject.projects_count.should == 1
+  end
+
+  it "doesn't have a member without a membership" do
+    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
+
+  it "is expired with a trial plan after 30 days" do
+    trial = Factory(:plan, :trial => true)
+    Factory(:account, :created_at => 30.days.ago, :plan => trial).should be_expired
+  end
+
+  it "isn't expired with a trial plan before 30 days" do
+    trial = Factory(:plan, :trial => true)
+    Factory(:account, :created_at => 29.days.ago, :plan => trial).should_not be_expired
+  end
+
+  it "isn't expired with a non-trial plan after 30 days" do
+    forever = Factory(:plan, :trial => false)
+    Factory(:account, :created_at => 30.days.ago, :plan => forever).should_not be_expired
+  end
+
+  it "isn't expired without an expiration date after 30 days" do
+    trial = Factory(:plan, :trial => true)
+    account = Factory(:account, :created_at => 30.days.ago, :plan => trial)
+    account.trial_expires_at = nil
+    account.save!
+    account.should_not be_expired
+  end
+
+  it "sends notifications for expiring accounts" do
+    trial   = Factory(:plan, :trial => true)
+    forever = Factory(:plan, :trial => false)
+
+    created_23_days  = Factory(:account, :plan => trial, :created_at => 23.days.ago)
+    expires_7_days   = Factory(:account, :plan => trial, :created_at => 1.day.ago)
+    expiring         = [created_23_days, expires_7_days]
+    forever          = Factory(:account, :plan => forever, :created_at => 23.days.ago)
+    new_trial        = Factory(:account, :plan => trial, :created_at => 22.days.ago)
+    already_notified = Factory(:account, :plan                   => trial,
+                                         :created_at             => 24.days.ago,
+                                         :notified_of_expiration => true)
+
+    expires_7_days.trial_expires_at = 7.days.from_now
+    expires_7_days.save!
+
+    mail = stub('mail', :deliver => true)
+    BillingMailer.stubs(:expiring_trial => mail)
+
+    Account.deliver_expiring_trial_notifications
+
+    expiring.each do |account|
+      BillingMailer.should have_received(:expiring_trial).with(account)
+    end
+
+    mail.should have_received(:deliver).twice
+
+    expiring.each { |account| account.reload.should be_notified_of_expiration }
+  end
+
+  it "sends notifications for completed trials" do
+    trial   = Factory(:plan, :trial => true)
+    forever = Factory(:plan, :trial => false)
+
+    unexpired_trial          = Factory(:account, :plan => trial, :created_at => 29.days.ago)
+    unnotified_expired_trial = Factory(:account, :plan => trial, :created_at => 31.days.ago)
+    expiring_now             = Factory(:account, :plan => trial, :created_at => 1.day.ago)
+    notified_expired_trial   = Factory(:account, :plan                         => trial,
+                                                 :created_at                   => 31.days.ago,
+                                                 :notified_of_completed_trial  => true)
+    forever                  = Factory(:account, :plan => forever, :created_at => 31.days.ago)
+
+    expiring_now.trial_expires_at = 1.day.ago
+    expiring_now.save!
+
+    requires_notification = [unnotified_expired_trial, expiring_now]
+
+    mail = stub('mail', :deliver => true)
+    BillingMailer.stubs(:completed_trial => mail)
+
+    Account.deliver_completed_trial_notifications
+
+    requires_notification.each do |account|
+      BillingMailer.should have_received(:completed_trial).with(account)
+    end
+
+    mail.should have_received(:deliver).twice
+
+    requires_notification.each { |account| account.reload.should be_notified_of_completed_trial }
+  end
+
+  it "sends notifications for unactivated accounts after 7 days" do
+    unactivated = [Factory(:account, :created_at => 7.days.ago),
+                   Factory(:account, :created_at => 8.days.ago)]
+    fresh = Factory(:account, :created_at => 6.days.ago)
+    activated = Factory(:account, :created_at => 9.days.ago, :activated => true)
+    already_notified = Factory(:account, :created_at        => 9.days.ago,
+                                         :asked_to_activate => true)
+
+    mail = stub('mail', :deliver => true)
+    BillingMailer.stubs(:new_unactivated => mail)
+
+    Account.deliver_new_unactivated_notifications
+
+    unactivated.each do |account|
+      BillingMailer.should have_received(:new_unactivated).with(account)
+    end
+
+    mail.should have_received(:deliver).twice
+
+    unactivated.each { |account| account.reload.should be_asked_to_activate }
+  end
+end
+

data/spec/models/invitation_spec.rb

@@ -0,0 +1,320 @@
+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 belong_to(:sender) }
+  it { should have_and_belong_to_many(:projects) }
+
+  it { should_not allow_mass_assignment_of(:account_id) }
+  it { should_not allow_mass_assignment_of(:used) }
+
+  %w(new_user_name new_user_email new_user_password authenticating_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) }
+  subject       { Factory(:invitation) }
+  let(:email)   { subject.email }
+  let(:code)    { 'abchex123' }
+
+  before do
+    SecureRandom.stubs(:hex => code)
+    InvitationMailer.stubs(:invitation => mail)
+    subject
+  end
+
+  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.authenticating_user_email.should == subject.email
+  end
+
+  it "generates a code" do
+    SecureRandom.should have_received(:hex).with(8)
+    subject.code.should == code
+  end
+
+  it "uses the code in the url" do
+    subject.to_param.should == code
+  end
+
+  it "delegates sender email" do
+    subject.sender_email.should == subject.sender.email
+  end
+
+  it "delegates sender name" do
+    subject.sender_name.should == subject.sender.name
+  end
+end
+
+describe Invitation, "valid accept for a new user" do
+  let(:account)  { Factory(:account) }
+  let(:projects) { [Factory(:project, :account => account)] }
+  let(:password) { 'secret' }
+  let(:name)     { 'Rocket' }
+  subject { Factory(:invitation, :account => account, :projects => projects) }
+
+  let!(:result) do
+    subject.accept(:new_user_password => password, :new_user_name => name)
+  end
+
+  let(:user) { subject.user }
+
+  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.name.should == name
+  end
+
+  it "adds the user to the account" do
+    account.users.should include(user)
+  end
+
+  it "adds the user to each of the invitation's projects" do
+    projects.each do |project|
+      user.should be_member_of(project)
+    end
+  end
+
+  it "marks the invitation as used" do
+    subject.reload.should be_used
+  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
+
+  it "doesn't mark the invitation as used" do
+    subject.reload.should_not be_used
+  end
+end
+
+describe Invitation, "valid accept for an existing user authenticating" do
+  let(:password) { 'secret' }
+  let(:user)     { Factory(:user, :password => password) }
+  subject        { Factory(:invitation, :email => user.email) }
+  let(:account)  { subject.account }
+
+  let!(:result) do
+    subject.accept(:authenticating_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
+
+  it "marks the invitation as used" do
+    subject.reload.should be_used
+  end
+end
+
+describe Invitation, "accepting with an invalid password" do
+  let(:user)    { Factory(:user) }
+  subject       { Factory(:invitation, :email => user.email) }
+  let(:account) { subject.account }
+  let!(:result) { subject.accept(:authenticating_user_password => 'wrong') }
+
+  it "adds error messages" do
+    subject.errors[:authenticating_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, "valid accept for an existing user specifically set" do
+  let(:user)     { Factory(:user) }
+  subject        { Factory(:invitation, :email => user.email) }
+  let(:account)  { subject.account }
+
+  let!(:result) do
+    subject.accept({:existing_user => user})
+  end
+
+  it "returns true" do
+    result.should be_true
+  end
+
+  it "adds the user to the account" do
+    account.users.should include(user)
+  end
+
+  it "marks the invitation as used" do
+    subject.reload.should be_used
+  end
+end
+
+describe Invitation, "saved" do
+  let(:mail)    { stub('invitation', :deliver => true) }
+  subject       { Factory(:invitation) }
+  let(:email)   { subject.email }
+  let(:code)    { 'abchex123' }
+
+  before do
+    SecureRandom.stubs(:hex => code)
+    InvitationMailer.stubs(:invitation => mail)
+    subject
+  end
+
+  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.authenticating_user_email.should == subject.email
+  end
+
+  it "generates a code" do
+    SecureRandom.should have_received(:hex).with(8)
+    subject.code.should == code
+  end
+
+  it "uses the code in the url" do
+    subject.to_param.should == code
+  end
+end
+
+describe Invitation, "valid accept for a new user" do
+  let(:account)  { Factory(:account) }
+  let(:projects) { [Factory(:project, :account => account)] }
+  let(:password) { 'secret' }
+  let(:name)     { 'Rocket' }
+  subject { Factory(:invitation, :account => account, :projects => projects) }
+
+  let!(:result) do
+    subject.accept(:new_user_password => password, :new_user_name => name)
+  end
+
+  let(:user) { subject.user }
+
+  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.name.should == name
+  end
+
+  it "adds the user to the account" do
+    account.users.should include(user)
+  end
+
+  it "adds the user to each of the invitation's projects" do
+    projects.each do |project|
+      user.should be_member_of(project)
+    end
+  end
+
+  it "marks the invitation as used" do
+    subject.reload.should be_used
+  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
+
+  it "doesn't mark the invitation as used" do
+    subject.reload.should_not be_used
+  end
+end
+
+describe Invitation, "accepting with an unknown email" do
+  subject       { Factory(:invitation, :email => 'unknown') }
+  let(:account) { subject.account }
+  let!(:result) { subject.accept(:authenticating_user_password => 'secret') }
+
+  it "adds error messages" do
+    subject.errors[:authenticating_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(:user, :password => password) }
+  subject        { Factory(:invitation, :email => user.email, :admin => true) }
+  let(:account)  { subject.account }
+
+  let!(:result) do
+    subject.accept(:authenticating_user_password => password)
+  end
+
+  it "adds the user as an admin" do
+    user.should be_admin_of(account)
+  end
+end