open_porch 0.5.0

data/test/functional/users_controller_test.rb

@@ -0,0 +1,144 @@
+require 'test_helper'
+
+class UsersControllerTest < ActionController::TestCase
+  def setup
+    @area = Area.create_dummy(
+      :name => 'Oakledge',
+      :border => Polygon.from_coordinates([[
+        [44.450713, -73.227265],
+        [44.456838, -73.225943],
+        [44.455921, -73.218375],
+        [44.449365, -73.220694],
+        [44.450713, -73.227265]
+      ]])
+    )
+  end
+  
+  def test_new_with_no_address
+    get :new
+    assert_redirected_to root_path
+  end
+  
+  def test_new
+    get :new, :user => {
+      :address=>"123 Fake St", 
+      :city=>"Burlington", 
+      :state=>"Vermont", 
+      :memberships_attributes=>{"0"=>{:area_id => @area.id}}
+    }
+    assert_response :success
+    assert_template 'new'
+    assert_equal assigns(:area), @area
+  end
+  
+  def test_create
+    assert_difference ['User.count', 'Membership.count'] do
+      assert_emails 1 do
+        post :create, :user => {
+          :email => 'user@example.com',
+          :password => 'tester',
+          :password_confirmation => 'tester',
+          :address=>"123 Fake St", 
+          :city=>"Burlington", 
+          :state=>"Vermont",
+          :first_name => 'John',
+          :last_name => 'Tester', 
+          :memberships_attributes=>{"0"=>{:area_id => @area.id}}
+        }
+        assert_redirected_to root_path
+        assert_equal 'Thank you, please check your email to complete the registration.', flash[:notice]
+        assert !@controller.logged_in?
+        assert_not_nil assigns(:user).email_verification_key
+        assert !assigns(:user).is_verified?
+      end
+    end
+    response = ActionMailer::Base.deliveries.last
+    assert_equal 2, response.arguments['content'].length
+    response.arguments['content'].each do |content_type, body|
+      assert_match assigns(:user).email_verification_key, body
+    end
+    assert_equal assigns(:user).email, response.to[0]
+    
+  end
+  
+  def test_create_fails
+    assert_no_difference ['User.count', 'Membership.count'] do
+      post :create, :user => {}
+      assert_redirected_to root_path
+    end
+  end
+  
+  def test_email_verification
+    user = a User
+    assert_created user
+    assert !user.is_verified?
+
+    area = an Area
+    assert_created area
+
+    user.areas << area
+    assert_equal area, user.areas.first
+    
+    user.set_email_verification_key
+    user.save!
+    assert !user.is_verified?
+    
+    get :verify_email, :email_verification_key => user.email_verification_key
+    assert_equal 'Your email address has been verified. You can now login', flash[:notice]
+    assert !@controller.logged_in?
+    assert_redirected_to login_path
+    user.reload
+    assert user.is_verified?
+  end
+  
+  def test_failed_email_verification
+    user = a User
+    assert_created user
+    assert !user.is_verified?
+
+    area = an Area
+    assert_created area
+
+    user.areas << area
+    assert_equal area, user.areas.first
+    
+    user.set_email_verification_key
+    user.save!
+    assert !user.is_verified?
+    
+    get :verify_email, :email_verification_key => 'bogus'
+    assert_equal 'We were not able to verify your account. Please contact us for assistance.', flash[:alert]
+    assert !@controller.logged_in?
+    user.reload
+    assert !user.is_verified?
+    assert_redirected_to root_path
+  end
+  
+  def test_resend_email_verification
+    user = a User
+    assert_created user
+    user.set_email_verification_key
+    user.save!
+    assert !user.is_verified?
+    
+    assert_emails 1 do
+      get :resend_email_verification, :email_verification_key => user.email_verification_key
+      assert_redirected_to login_path
+      response = ActionMailer::Base.deliveries.last
+      assert_equal 2, response.arguments['content'].length
+      response.arguments['content'].each do |content_type, body|
+        assert_match assigns(:user).email_verification_key, body
+      end
+      assert_equal assigns(:user).email, response.to[0]
+    end
+  end
+  
+  def test_destroy
+    login_as(:regular_user)
+    assert_difference 'User.count', -1 do
+      delete :destroy
+    end
+    assert_equal "Your account has been deleted.", flash[:alert]
+    assert_redirected_to root_path
+  end
+end

data/test/performance/browsing_test.rb

@@ -0,0 +1,9 @@
+require 'test_helper'
+require 'rails/performance_test_help'
+
+# Profiling results for each test method are written to tmp/performance.
+class BrowsingTest < ActionDispatch::PerformanceTest
+  def test_homepage
+    get '/'
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,92 @@
+ENV["RAILS_ENV"] = "test"
+require File.expand_path('../../config/environment', __FILE__)
+require 'rails/test_help'
+
+class ActiveSupport::TestCase
+  self.use_transactional_fixtures = true
+  self.use_instantiated_fixtures = false
+  include ActionMailer::TestHelper
+  
+  def data_path(name)
+    File.expand_path(File.join('test', 'data', name), Rails.root)
+  end
+
+  def assert_created(model)
+    assert model
+    assert_equal [ ], model.errors.full_messages
+    assert model.valid?
+    assert !model.new_record?
+  end
+  
+  def assert_not_created(model)
+    assert model
+    assert model.new_record?
+  end
+  
+  def assert_errors_on(model, *attrs)
+    found_attrs = [ ]
+    
+    model.errors.each do |attr, error|
+      found_attrs << attr
+    end
+    
+    assert_equal attrs.flatten.collect(&:to_s).sort, found_attrs.uniq.collect(&:to_s).sort
+  end
+  
+  def assert_mapping(map, &block)
+    result_map = map.inject({ }) do |h, (k,v)|
+      h[k] = yield(k)
+      h
+    end
+    
+    differences = result_map.inject([ ]) do |a, (k,v)|
+      if (v != map[k])
+        a << k
+      end
+      a
+    end
+    assert_equal map, result_map, "Difference: #{map.slice(*differences).inspect} vs #{result_map.slice(*differences).inspect}"
+  end
+  
+  def login_as(obj)
+    case obj
+    when String
+      user = a User
+      user.update_attribute(:role, obj)
+    when Symbol
+      user = a User
+      user.update_attribute(:role, obj.to_s)
+    when User
+      user = obj
+    else
+      raise "Please specifuy either a User or a role: #{obj.class.to_s}"
+    end
+
+    session[:user_id] = user.id
+    token = Wristband::Support.encrypt_with_salt(user.id.to_s, Time.now.to_f.to_s)
+    cookies[:login_token] = {
+      :value => token,
+      :expires => 2.weeks.from_now.utc
+    }
+    
+    user
+  end
+  
+  def assert_exception_raised(exception_class = nil, error_message = nil, &block)
+    exception_raised = nil
+    yield
+  rescue => exception_raised
+  ensure
+    if exception_raised
+      if exception_class
+        assert_equal exception_class, exception_raised.class, exception_raised.to_s
+      else
+        assert true
+      end
+      assert_equal error_message, exception_raised.to_s if error_message
+    else
+      flunk 'Exception was not raised'
+    end
+  end
+
+end

data/test/unit/address_test.rb

@@ -0,0 +1,25 @@
+require 'test_helper'
+
+class AddressTest < ActiveSupport::TestCase
+  
+  def test_create_defaults
+    address = Address.new(
+      :address => '123 Fake St',
+      :city => 'Burlington',
+      :state => 'Vermont'
+    )
+    assert address.valid?
+    assert_equal address.address, '123 Fake St'
+    assert_equal address.city, 'Burlington'
+    assert_equal address.state, 'Vermont'
+  end
+  
+  def test_create_requirements
+    address = Address.new
+    assert !address.valid?
+    assert_errors_on address, :address, :city, :state
+    assert address.errors[:address].include?("Please enter your address")
+    assert address.errors[:city].include?("Please enter your address")
+    assert address.errors[:state].include?("Please enter your address")
+  end
+end

data/test/unit/area_activity_test.rb

@@ -0,0 +1,57 @@
+require 'test_helper'
+
+class AreaActivityTest < ActiveSupport::TestCase
+
+  def test_create_dummy
+    activity = an AreaActivity
+    assert_created activity
+  end
+  
+  def test_activity_tracking_for_memberships
+    # Memberships
+    assert_difference 'AreaActivity.count', 1 do
+      @membership = Membership.create_dummy
+      assert_equal 1, @membership.area.activities.first.new_users_count
+    end
+    assert_no_difference 'AreaActivity.count' do
+      @membership.destroy
+      assert_equal 1, @membership.area.activities.first.quitters_count
+    end
+  end
+  
+  def test_activity_tracking_for_posts  
+    # Posts
+    assert_difference ['Post.count', 'AreaActivity.count'], 1 do
+      post = Post.create_dummy
+      assert_equal 1, post.area.activities.first.new_posts_count
+    end
+  end
+  
+  def test_activity_tracking_for_issues
+    # Create an area
+    area = an Area
+    assert_created area
+    assert area.send_mode?(:immediate)
+    
+    # Create en issue
+    assert_difference ['Post.count', 'Issue.count', 'AreaActivity.count'], 1 do
+      assert_emails 1 do
+        post = area.posts.create_dummy
+        assert_created post
+        assert_nil area.current_issue
+        assert_equal 1, area.activities.first.issues_published_count
+      end
+    end
+  end
+  
+  def test_activity_tracking_for_nonexistent_field
+    area = an Area
+    assert_created area
+    assert_exception_raised nil, "Cannot find field in the list of trackable fields. Currently tracking: #{AreaActivity::TRACKABLE.join(', ')}" do
+      assert_no_difference 'AreaActivity.count' do
+        area.record_activity_for!(:blah)
+      end
+    end
+  end
+
+end

data/test/unit/area_test.rb

@@ -0,0 +1,92 @@
+require 'test_helper'
+
+class AreaTest < ActiveSupport::TestCase
+
+  def test_create_defaults
+    area = Area.create(
+      :name => 'Test Area'
+    )
+    assert_created area
+    assert_equal 'immediate', area.send_mode
+  end
+  
+  def test_create_requirements
+    area = Area.create
+    assert_errors_on area, :name
+    Area.create(:name => 'Test NF', :slug => 'test-nf')
+    assert_no_difference 'Area.count' do
+      ['test-nf', 'test nf', 'test#NF'].each do |slug|
+        area = Area.create(:name => 'Test NF 2', :slug => slug)
+        assert_errors_on area, :slug
+      end
+    end
+  end
+  
+  def test_create_dummy
+    area = an Area
+    assert_created area
+  end
+
+  def test_cascade_deletions
+    area = an Area
+    assert_created area
+    membership = area.memberships.create_dummy
+    assert_created membership
+    post = area.posts.create_dummy  
+    assert_created post
+    # Note: Creating a membership and post will also create an AreaActivity,
+    # so no need to create that separately.
+    area.reload
+    assert_difference ['Area.count', 'Membership.count', 'Post.count', 'Issue.count', 'AreaActivity.count'], -1 do
+      area.destroy
+    end
+  end
+  
+  def test_record_activity_for
+    area = an Area
+    assert_equal 0, area.activities.count
+    assert_difference 'AreaActivity.count', 1 do
+      activity = area.record_activity_for!(:quitters)
+      assert_equal 1, activity.quitters_count
+    end
+    assert_no_difference 'AreaActivity.count' do
+      activity = area.record_activity_for!(:quitters)
+      assert_equal 2, activity.quitters_count
+    end
+  end
+  
+  def test_check_send_mode_change
+    area = Area.create_dummy(:send_mode => 'batched')
+    assert_created area
+    assert area.send_mode?(:batched)
+
+    posts = []
+    # Create 5 posts
+    assert_difference 'Post.count', 5 do
+      assert_difference 'Issue.count' do
+        assert_emails 0 do
+          1.upto(5){ posts << area.posts.create_dummy }
+        end
+      end
+    end
+    assert_not_nil area.current_issue
+    assert area.current_issue.posts.empty?
+    
+    # Assign the first 2 posts to the current issue
+    0.upto(1){ |i| posts[i].update_attribute(:issue_id, area.current_issue.id) }
+    area.current_issue.reload
+    assert_equal 2, area.current_issue.posts.length
+    
+    
+    assert_no_difference 'Post.count' do
+      assert_difference 'Issue.count', 4 do
+        assert_emails 5 do
+          area.send_mode = 'immediate'
+          area.save!
+          assert area.send_mode?(:immediate)
+          assert_nil area.current_issue
+        end
+      end
+    end
+  end
+end

data/test/unit/email_message_test.rb

@@ -0,0 +1,8 @@
+require 'test_helper'
+
+class EmailMessageTest < ActiveSupport::TestCase
+  # Replace this with your real tests.
+  test "the truth" do
+    assert true
+  end
+end

data/test/unit/issue_number_test.rb

@@ -0,0 +1,25 @@
+require 'test_helper'
+
+class IssueNumberTest < ActiveSupport::TestCase
+  def test_defaults
+    assert_difference ['Area.count', 'IssueNumber.count'] do
+      area = an Area
+      assert_created area
+      assert_created area.issue_number
+    
+      assert_equal 0, area.issue_number.current
+      assert_equal 1, area.issue_number.next
+      assert_equal 1, area.issue_number.current
+      assert_equal 2, area.issue_number.next
+      assert_equal 2, area.issue_number.current
+    end
+  end
+  
+  def test_cascade_deletions
+    area = an Area
+    assert_difference ['Area.count', 'IssueNumber.count'], -1 do
+      area.destroy
+    end
+  end
+  
+end

data/test/unit/issue_test.rb

@@ -0,0 +1,154 @@
+require 'test_helper'
+
+class IssueTest < ActiveSupport::TestCase
+
+  def test_create_defaults
+    area = an Area
+    issue = Issue.create(
+      :area => area,
+      :scheduled_at => 2.days.from_now
+    )
+    assert_equal 1, issue.number
+    assert_created issue
+  end
+  
+  def test_create_requirements
+    issue = Issue.create(:scheduled_at => 2.days.ago)
+    assert_errors_on issue, :area_id, :scheduled_at
+    assert issue.errors[:scheduled_at].include?("can't be in the past.")
+  end
+  
+  def test_create_dummy
+   issue = an Issue
+   assert_created issue
+  end
+  
+  def test_cascade_deletions
+    post = a Post
+    assert_created post
+    assert post.issue.is_a?(Issue)
+    post.reload
+    assert_difference ['Post.count', 'Issue.count'], -1 do
+      post.issue.destroy
+    end
+  end
+  
+  def test_send_in_immediate_mode!
+    # Create an area
+    area = an Area
+    assert_created area
+    assert area.send_mode?(:immediate)
+    
+    # Create en issue
+    assert_difference ['Post.count', 'Issue.count'], 1 do
+      assert_emails 1 do
+        post = area.posts.create_dummy
+        assert_created post
+        assert_nil area.current_issue
+      end
+    end
+  end
+  
+  def test_send_in_batched_mode!
+    # Create an area
+    area = Area.create_dummy(:send_mode => 'batched')
+    assert_created area
+    assert area.send_mode?(:batched)
+    
+    # Create an issue
+    issue = area.issues.create_dummy
+    assert_created issue
+    assert_nil issue.sent_at
+    assert_equal issue, area.current_issue
+    
+    # Add two posts to the area
+    post_1 = area.posts.create_dummy
+    assert_created post_1
+    assert_equal post_1.area, area
+    
+    post_2 = area.posts.create_dummy
+    assert_created post_2
+    assert_equal post_2.area, area
+    
+    assert_equal [post_1, post_2], area.posts.order(:id)
+    assert_equal [], area.posts.in_issue(issue)
+    assert_equal [post_1, post_2], area.posts.in_issue(nil).order(:id)
+
+    # Add one post to the issue
+    post_1.update_attribute(:issue_id, issue.id)
+    area.reload
+    assert_equal [post_1], area.posts.in_issue(issue)
+    assert_equal [post_2], area.posts.in_issue(nil)
+
+    # Send the issue
+    assert_emails 1 do
+      # Another issue should be created
+      assert_difference 'Issue.count' do
+        issue.send!
+        assert issue.sent_at.is_a?(Time)
+        area = Area.find(area.id)
+        assert_not_equal issue, area.current_issue
+      end
+    end
+
+    issue = area.current_issue
+    assert_equal [], area.posts.in_issue(issue)
+    assert_equal [post_2], area.posts.in_issue(nil)
+
+    # Add the second post to the issue
+    post_2.update_attribute(:issue_id, issue.id)
+    area.reload
+    assert_equal [post_2], area.posts.in_issue(issue)
+    assert_equal [], area.posts.in_issue(nil)
+    
+    # Send the second issue
+    assert_emails 1 do
+      # No new issue should be created
+      assert_no_difference 'Issue.count' do
+        issue.send!
+        assert issue.sent_at.is_a?(Time)
+        area = Area.find(area.id)
+        assert_nil area.current_issue
+      end
+    end
+  end
+
+  def test_issue_number
+    # Create one area
+    area = an Area
+    assert_created area
+    
+    # Add an issue
+    issue = area.issues.create_dummy
+    assert_created issue
+    area.reload
+    assert_equal 1, issue.number
+    assert_equal 1, area.issue_number.current
+    
+    # Add another issue
+    issue = area.issues.create_dummy
+    assert_created issue
+    area.reload
+    assert_equal 2, issue.number
+    assert_equal 2, area.issue_number.current
+    
+    # Create another area
+    area = an Area
+    assert_created area
+    
+    # Add an issue
+    issue = area.issues.create_dummy
+    assert_created issue
+    area.reload
+    assert_equal 1, issue.number
+    assert_equal 1, area.issue_number.current
+    
+    # Add another issue
+    issue = area.issues.create_dummy
+    assert_created issue
+    area.reload
+    assert_equal 2, issue.number
+    assert_equal 2, area.issue_number.current
+  end
+
+end

data/test/unit/membership_test.rb

@@ -0,0 +1,20 @@
+require 'test_helper'
+
+class MembershipTest < ActiveSupport::TestCase
+  
+  def test_validations
+    # Uniqueness
+    membership = Membership.create_dummy
+    assert_created membership
+    membership = membership.clone
+    membership.save
+    assert_not_created membership
+    assert membership.errors[:user_id].include?("has already been taken")
+  end
+  
+  def test_create_dummy
+    membership = Membership.create_dummy
+    assert_created membership      
+  end
+  
+end

data/test/unit/post_test.rb

@@ -0,0 +1,69 @@
+require 'test_helper'
+
+class PostTest < ActiveSupport::TestCase
+  
+  def test_create_defaults
+    assert_difference ['Post.count', 'Issue.count'], 1 do
+      post = Post.create(
+        :title => 'Test Post',
+        :content => 'Lorem ipsum dolor sit amet',
+        :user => (a User),
+        :area => (an Area)
+      )
+      assert post.area.send_mode?(:immediate)
+    end
+  end
+  
+  def test_create_requirements
+    post = Post.create
+    assert_errors_on post, :title, :content, :user_id, :area_id, :user_first_name,
+                           :user_last_name, :user_email, :user_address, :user_city,
+                           :user_state
+  end
+  
+  def test_create_dummy
+    area = Area.create_dummy(:send_mode => 'batched')
+    assert_created area
+    assert area.send_mode?(:batched)
+    assert area.issues.empty?
+
+    # Creating the first post will also create an issue
+    assert_difference ['Post.count', 'Issue.count'] do
+      assert_emails 0 do
+        post = area.posts.create_dummy
+        assert_created post
+        assert_equal post.area.id, area.id
+      end
+    end
+
+    # The second post will NOT create a new issue
+    assert_difference 'Post.count' do
+      assert_no_difference 'Issue.count' do
+        assert_emails 0 do
+          post = area.posts.create_dummy
+          assert_created post
+        end
+      end
+    end
+  end
+
+  def test_send_immediatelly
+    area = Area.create_dummy(:send_mode => 'batched')
+    assert_created area
+    assert area.send_mode?(:batched)
+
+    post = nil
+    assert_difference ['Post.count', 'Issue.count'] do
+      assert_emails 0 do
+        post = area.posts.create_dummy
+      end
+    end
+    
+    assert_difference 'Issue.count' do
+      assert_emails 1 do
+        post.send_immediatelly!
+      end
+    end
+    
+  end
+end