")
45 | end
46 |
47 | it "handle back-slashes in code block" do
48 | # This could use some more extensive tests
49 | format("```\nf\\'oo\n```").strip.should include("f\\'oo")
50 | end
51 |
52 | it "does not allow html" do
53 | format("
![]()
").strip.should eq("")
54 | end
55 | end
56 |
--------------------------------------------------------------------------------
/spec/mailers/mailer_spec.rb:
--------------------------------------------------------------------------------
1 | require "spec_helper"
2 |
3 | describe Mailer do
4 | describe "feedback" do
5 | let(:message) { Factory(:feedback_message) }
6 | let(:mail) { Mailer.feedback(message) }
7 |
8 | it "includes message with name and email" do
9 | mail.subject.should eq("RailsCasts Feedback from #{message.name}")
10 | mail.to.should eq(["feedback@railscasts.com"])
11 | mail.from.should eq([message.email])
12 | mail.body.encoded.should match(message.content)
13 | end
14 | end
15 |
16 | describe "comment_response" do
17 | let(:user) { Factory(:user) }
18 | let(:comment) { Factory(:comment) }
19 | let(:mail) { Mailer.comment_response(comment, user) }
20 |
21 | it "includes comment content and link to comment page" do
22 | mail.subject.should eq("Comment Response on RailsCasts")
23 | mail.to.should eq([user.email])
24 | mail.from.should eq(["noreply@railscasts.com"])
25 | mail.body.encoded.should include(comment.content)
26 | mail.body.encoded.should include(episode_url(comment.episode, :view => "comments"))
27 | mail.body.encoded.should include(unsubscribe_url(user.generated_unsubscribe_token))
28 | end
29 | end
30 | end
31 |
--------------------------------------------------------------------------------
/spec/models/ability_spec.rb:
--------------------------------------------------------------------------------
1 | require "spec_helper"
2 | require "cancan/matchers"
3 |
4 | describe "Ability" do
5 | describe "as guest" do
6 | before(:each) do
7 | @ability = Ability.new(nil)
8 | end
9 |
10 | it "can only view and create users" do
11 | @ability.should be_able_to(:login, :users)
12 | @ability.should be_able_to(:show, :users)
13 | @ability.should be_able_to(:create, :users)
14 | @ability.should be_able_to(:unsubscribe, :users)
15 | @ability.should_not be_able_to(:update, :users)
16 | end
17 |
18 | it "can only view episodes which are published" do
19 | @ability.should be_able_to(:index, :episodes)
20 | @ability.should be_able_to(:show, Factory.build(:episode, :published_at => 2.days.ago))
21 | @ability.should_not be_able_to(:show, Factory.build(:episode, :published_at => 2.days.from_now))
22 | @ability.should_not be_able_to(:create, :episodes)
23 | @ability.should_not be_able_to(:update, :episodes)
24 | @ability.should_not be_able_to(:destroy, :episodes)
25 | end
26 |
27 | it "can access any info pages" do
28 | @ability.should be_able_to(:access, :info)
29 | end
30 |
31 | it "can create feedback messages" do
32 | @ability.should be_able_to(:create, :feedback_messages)
33 | end
34 |
35 | it "cannot even create comments" do
36 | @ability.should_not be_able_to(:create, :comments)
37 | @ability.should_not be_able_to(:update, :comments)
38 | @ability.should_not be_able_to(:destroy, :comments)
39 | @ability.should_not be_able_to(:index, :comments)
40 | end
41 | end
42 |
43 | describe "as normal user" do
44 | before(:each) do
45 | @user = Factory(:user)
46 | @ability = Ability.new(@user)
47 | end
48 |
49 | it "can update himself, but not other users" do
50 | @ability.should be_able_to(:show, User.new)
51 | @ability.should be_able_to(:login, :users)
52 | @ability.should be_able_to(:logout, :users)
53 | @ability.should be_able_to(:create, :users)
54 | @ability.should be_able_to(:update, @user)
55 | @ability.should_not be_able_to(:update, User.new)
56 | @ability.should_not be_able_to(:ban, :users)
57 | end
58 |
59 | it "can create comments and update/destroy within 15 minutes if he owns them" do
60 | @ability.should be_able_to(:create, :comments)
61 | @ability.should be_able_to(:update, Factory(:comment, :user => @user, :created_at => 10.minutes.ago))
62 | @ability.should_not be_able_to(:update, Factory(:comment, :user => @user, :created_at => 20.minutes.ago))
63 | @ability.should be_able_to(:destroy, Factory(:comment, :user => @user, :created_at => 10.minutes.ago))
64 | @ability.should_not be_able_to(:destroy, Factory(:comment, :user => @user, :created_at => 20.minutes.ago))
65 | @ability.should_not be_able_to(:destroy, Factory(:comment, :user => User.new, :created_at => 10.minutes.ago))
66 | end
67 |
68 | it "can create feedback messages" do
69 | @ability.should be_able_to(:create, :feedback_messages)
70 | end
71 |
72 | it "can only view episodes which are published" do
73 | @ability.should be_able_to(:index, :episodes)
74 | @ability.should be_able_to(:show, Factory.build(:episode, :published_at => 2.days.ago))
75 | @ability.should_not be_able_to(:show, Factory.build(:episode, :published_at => 2.days.from_now))
76 | @ability.should_not be_able_to(:create, :episodes)
77 | @ability.should_not be_able_to(:update, :episodes)
78 | @ability.should_not be_able_to(:destroy, :episodes)
79 | end
80 |
81 | it "can access any info pages" do
82 | @ability.should be_able_to(:access, :info)
83 | end
84 | end
85 |
86 | describe "as banned user" do
87 | before(:each) do
88 | @user = Factory(:user, :banned_at => Time.now)
89 | @ability = Ability.new(@user)
90 | end
91 |
92 | it "cannot create or update comments" do
93 | @ability.should_not be_able_to(:create, :comments)
94 | @ability.should_not be_able_to(:update, :comments)
95 | end
96 | end
97 |
98 | describe "as moderator" do
99 | before(:each) do
100 | @user = Factory(:user, :moderator => true)
101 | @ability = Ability.new(@user)
102 | end
103 |
104 | it "can ban users" do
105 | @ability.should be_able_to(:ban, :users)
106 | end
107 |
108 | it "can revert versions" do
109 | @ability.should be_able_to(:revert, :versions)
110 | end
111 |
112 | it "can list, update and destroy any comments" do
113 | @ability.should be_able_to(:update, Factory(:comment, :user => User.new, :created_at => 20.minutes.ago))
114 | @ability.should be_able_to(:destroy, Factory(:comment, :user => User.new, :created_at => 20.minutes.ago))
115 | @ability.should be_able_to(:index, :comments)
116 | end
117 |
118 | it "can view episodes which are not yet published" do
119 | @ability.should be_able_to(:index, Factory.build(:episode, :published_at => 2.days.from_now))
120 | @ability.should be_able_to(:show, Factory.build(:episode, :published_at => 2.days.from_now))
121 | end
122 |
123 | it "can update episode show notes, nothing else" do
124 | @ability.should be_able_to(:update, :episodes, :notes)
125 | @ability.should_not be_able_to(:update, :episodes, :name)
126 | @ability.should_not be_able_to(:update, :episodes, :name)
127 | @ability.should_not be_able_to(:destroy, :episodes)
128 | end
129 | end
130 |
131 | describe "as admin" do
132 | it "can access all" do
133 | user = Factory(:user, :admin => true)
134 | ability = Ability.new(user)
135 | ability.should be_able_to(:access, :all)
136 | end
137 | end
138 | end
139 |
--------------------------------------------------------------------------------
/spec/models/comment_spec.rb:
--------------------------------------------------------------------------------
1 | require "spec_helper"
2 | require "ostruct"
3 |
4 | describe Comment do
5 | it "validates the presence of episode_id and content" do
6 | comment = Comment.new
7 | %w[episode_id content].each do |attr|
8 | comment.should have(1).error_on(attr)
9 | end
10 | end
11 |
12 | it "sets request based attributes" do
13 | comment = Factory.build(:comment, :site_url => 'example.com')
14 | comment.request = OpenStruct.new(:remote_ip => 'ip', :env => { 'HTTP_USER_AGENT' => 'agent', 'HTTP_REFERER' => 'referrer' })
15 | comment.user_ip.should eq('ip')
16 | comment.user_agent.should eq('agent')
17 | comment.referrer.should eq('referrer')
18 | end
19 |
20 | it "sorts recent comments in descending order by created_at time" do
21 | Comment.delete_all
22 | c1 = Factory(:comment, :created_at => 2.weeks.ago)
23 | c2 = Factory(:comment, :created_at => Time.now)
24 | Comment.recent.should eq([c2, c1])
25 | end
26 |
27 | it "notifies owners of all previous commenters except self" do
28 | c1 = Factory(:comment)
29 | c2a = Factory(:comment, :parent => c1)
30 | c2b = Factory(:comment, :parent => c1)
31 | c3 = Factory(:comment, :parent => c2a, :user => c2a.user)
32 | c3.notify_other_commenters
33 | email_count.should eq(1)
34 | last_email.to.should include(c1.user.email)
35 | end
36 |
37 | it "does not notify user when user does not want email" do
38 | c1 = Factory(:comment, :user => nil)
39 | c2 = Factory(:comment, :parent => c2, :user => Factory(:user, :email_on_reply => false))
40 | c3 = Factory(:comment, :parent => c2, :user => Factory(:user, :email => ""))
41 | c4 = Factory(:comment, :parent => c3)
42 | c4.users_to_notify.should eq([])
43 | end
44 |
45 | it "searches by comment site url" do
46 | c1 = Factory(:comment, :site_url => "http://example.com")
47 | c2 = Factory(:comment, :site_url => "http://example2.com")
48 | Comment.search("example.com").should eq([c1])
49 | end
50 | end
51 |
--------------------------------------------------------------------------------
/spec/models/episode_spec.rb:
--------------------------------------------------------------------------------
1 | require "spec_helper"
2 |
3 | describe Episode do
4 | it "finds published" do
5 | a = Factory(:episode, :published_at => 2.weeks.ago)
6 | b = Factory(:episode, :published_at => 2.weeks.from_now)
7 | Episode.published.should include(a)
8 | Episode.published.should_not include(b)
9 | end
10 |
11 | it "finds unpublished" do
12 | a = Factory(:episode, :published_at => 2.weeks.ago)
13 | b = Factory(:episode, :published_at => 2.weeks.from_now)
14 | Episode.unpublished.should include(b)
15 | Episode.unpublished.should_not include(a)
16 | end
17 |
18 | it "sorts recent episodes in descending order" do
19 | Episode.delete_all
20 | e1 = Factory(:episode, :position => 1)
21 | e2 = Factory(:episode, :position => 2)
22 | Episode.recent.should eq([e2, e1])
23 | end
24 |
25 | it "assigns tags to episodes" do
26 | episode = Factory(:episode, :tag_names => 'foo bar')
27 | episode.tags.map(&:name).should eq(%w[foo bar])
28 | episode.tag_names.should eq('foo bar')
29 | end
30 |
31 | it "requires publication date and name" do
32 | episode = Episode.new
33 | episode.should have(1).error_on(:published_at)
34 | episode.should have(1).error_on(:name)
35 | end
36 |
37 | it "automatically generates permalink when creating episode" do
38 | episode = Factory(:episode, :name => ' Hello_ *World* 2.1. ')
39 | episode.permalink.should eq('hello-world-2-1')
40 | end
41 |
42 | it "includes position and permalink in to_param" do
43 | episode = Factory(:episode, :name => 'Foo Bar')
44 | episode.to_param.should eq("#{episode.position}-foo-bar")
45 | end
46 |
47 | it "translates single digit seconds into duration with minutes" do
48 | Episode.new(:seconds => 60*8+3).duration.should eq('8:03')
49 | end
50 |
51 | it "translates double digit seconds into duration with minutes" do
52 | Episode.new(:seconds => 60*8+12).duration.should eq('8:12')
53 | end
54 |
55 | it "returns nil for duration if seconds aren't set" do
56 | Episode.new(:seconds => nil).duration.should be_nil
57 | end
58 |
59 | it "parses duration into seconds" do
60 | Episode.new(:duration => '10:03').seconds.should eq(603)
61 | Episode.new(:duration => '').seconds.should be_nil
62 | end
63 |
64 | it "knows if it's the last published episode" do
65 | a = Factory(:episode, :published_at => 2.weeks.ago)
66 | b = Factory(:episode, :published_at => 1.week.ago)
67 | c = Factory(:episode, :published_at => 2.weeks.from_now)
68 | a.should_not be_last_published
69 | b.should be_last_published
70 | c.should_not be_last_published
71 | end
72 |
73 | it "has media.railscasts.com asset url" do
74 | episode = Factory(:episode, :name => "Hello world")
75 | episode.position = 23
76 | episode.asset_url("videos").should eq("http://media.railscasts.com/assets/episodes/videos/023-hello-world")
77 | episode.asset_url("videos", "mp4").should eq("http://media.railscasts.com/assets/episodes/videos/023-hello-world.mp4")
78 | end
79 |
80 | it "has files with file sizes" do
81 | episode = Factory(:episode, :name => "Hello world", :file_sizes => {"zip" => "12345"})
82 | episode.files[0][:name].should eq("source code")
83 | episode.files.map { |f| f[:name] }.should eq(["source code", "mp4", "m4v", "webm", "ogv"])
84 | episode.files.map { |f| f[:info] }.should eq(["Project Files in Zip", "Full Size H.264 Video", "Smaller H.264 Video", "Full Size VP8 Video", "Full Size Theora Video"])
85 | episode.files[0][:url].should include("http://media.railscasts.com/assets/episodes/sources/")
86 | episode.files[0][:size].should eq(12345)
87 | end
88 |
89 | it "sets file size to zero when unknown" do
90 | episode = Factory(:episode, :name => "Hello world", :file_sizes => nil)
91 | episode.files[0][:size].should eq(0)
92 | end
93 |
94 | it "loads the file sizes for each file" do
95 | episode = Factory(:episode, :name => "Hello world")
96 | episode.position = 42
97 | %w[mp4 m4v webm ogv].each_with_index do |ext, index|
98 | FakeWeb.register_uri(:head, "http://media.railscasts.com/assets/episodes/videos/042-hello-world.#{ext}", :content_length => index)
99 | end
100 | FakeWeb.register_uri(:head, "http://media.railscasts.com/assets/episodes/sources/042-hello-world.zip", :content_length => 4)
101 | episode.load_file_sizes
102 | episode.file_sizes.should eq(
103 | "mp4" => "0",
104 | "m4v" => "1",
105 | "webm" => "2",
106 | "ogv" => "3",
107 | "zip" => "4"
108 | )
109 | end
110 |
111 | it "returns nil as file size when response is not 200" do
112 | FakeWeb.register_uri(:head, "http://example.com/foo", :content_length => "123", :status => ["404", "Not Found"])
113 | episode = Factory.build(:episode)
114 | episode.fetch_file_size("http://example.com/foo").should eq(nil)
115 | end
116 |
117 | it "has a full name which includes position" do
118 | Episode.delete_all
119 | Factory(:episode, :position => 123, :name => "Foo Bar").full_name.should eq('#123 Foo Bar')
120 | end
121 |
122 | it "knows the next and previous episode based on position" do
123 | Episode.delete_all
124 | e1 = Factory(:episode, :position => 1)
125 | e2 = Factory(:episode, :position => 6)
126 | e1.previous.should be_nil
127 | e1.next.should eq(e2)
128 | e2.next.should be_nil
129 | e2.previous.should eq(e1)
130 | end
131 |
132 | describe "primitive search" do
133 | before(:each) do
134 | Episode.delete_all
135 | APP_CONFIG['thinking_sphinx'] = false
136 | end
137 |
138 | it "looks in name, description, and notes" do
139 | e1 = Factory(:episode, :name => 'foo', :description => 'bar', :notes => 'baz', :published_at => 2.weeks.ago)
140 | e2 = Factory(:episode, :name => 'foo test bar', :description => 'baz', :published_at => 2.weeks.ago)
141 | e3 = Factory(:episode, :name => 'foo', :published_at => 2.weeks.ago)
142 | Episode.search_published('foo bar baz').should eq([e1, e2])
143 | end
144 |
145 | it "does not find unpublished" do
146 | e1 = Factory(:episode, :name => 'foo', :published_at => 2.weeks.ago)
147 | e2 = Factory(:episode, :name => 'foo', :published_at => 2.weeks.from_now)
148 | Episode.search_published('foo').should eq([e1])
149 | end
150 | end
151 | end
152 |
--------------------------------------------------------------------------------
/spec/models/feedback_message_spec.rb:
--------------------------------------------------------------------------------
1 | require "spec_helper"
2 |
3 | describe FeedbackMessage do
4 | it "validates the presence of name, email and content" do
5 | feedback_message = FeedbackMessage.new
6 | %w[name email content].each do |attr|
7 | feedback_message.should have(1).error_on(attr)
8 | end
9 | end
10 | end
11 |
--------------------------------------------------------------------------------
/spec/models/tag_spec.rb:
--------------------------------------------------------------------------------
1 | require "spec_helper"
2 |
3 | describe Tag do
4 | it "finds or creates tags with names" do
5 | Tag.delete_all
6 | Tag.create!(:name => 'foo')
7 | tags = Tag.with_names(['foo', 'bar'])
8 | tags.should have(2).records
9 | Tag.find(:all).should eq(tags)
10 | end
11 | end
12 |
--------------------------------------------------------------------------------
/spec/models/tagging_spec.rb:
--------------------------------------------------------------------------------
1 | require "spec_helper"
2 |
3 | describe Tagging do
4 | before(:each) do
5 | @tagging = Tagging.new
6 | end
7 |
8 | it "is valid" do
9 | @tagging.should be_valid
10 | end
11 | end
12 |
--------------------------------------------------------------------------------
/spec/models/user_spec.rb:
--------------------------------------------------------------------------------
1 | require "spec_helper"
2 |
3 | describe User do
4 | it "creates unique token when saving" do
5 | User.create!.token.should_not == User.create!.token
6 | end
7 |
8 | it "creates from omniauth hash" do
9 | omniauth = {"provider" => "github", "uid" => "123", "user_info" => {}, "extra" => {"user_hash" => {}}}
10 | omniauth["user_info"]["email"] = "foo@example.com"
11 | omniauth["user_info"]["name"] = "Bar"
12 | omniauth["user_info"]["nickname"] = "foo"
13 | omniauth["user_info"]["urls"] = {"GitHub" => "githubsite", "Blog" => "customsite"}
14 | omniauth["extra"]["user_hash"]["gravatar_id"] = "avatar"
15 | user = User.create_from_omniauth(omniauth)
16 | user.email.should eq("foo@example.com")
17 | user.github_uid.should eq("123")
18 | user.github_username.should eq("foo")
19 | user.name.should eq("Bar")
20 | user.gravatar_token.should eq("avatar")
21 | user.site_url.should eq("customsite")
22 | user.email_on_reply.should be_true
23 | user
24 | end
25 |
26 | it "generates persistant unsubscribe_token" do
27 | user = Factory(:user)
28 | user.unsubscribe_token.should be_nil
29 | token = user.generated_unsubscribe_token
30 | user.reload.unsubscribe_token.should eq(token)
31 | user.generated_unsubscribe_token.should eq(token)
32 | end
33 |
34 | it "uses github name as display name when original is blank" do
35 | Factory(:user, :name => "", :github_username => "hank").display_name.should eq("hank")
36 | end
37 | end
38 |
--------------------------------------------------------------------------------
/spec/requests/comments_request_spec.rb:
--------------------------------------------------------------------------------
1 | require 'spec_helper'
2 |
3 | describe "Comments request" do
4 | it "creates and replies when not signed in" do
5 | episode = Factory(:episode, :name => "Blast from the Past")
6 | visit episode_path(episode)
7 | click_on "0 Comments"
8 | click_on "sign in through GitHub"
9 | page.should have_content("New comment")
10 | click_on "Post Comment"
11 | page.should have_content("Invalid Fields")
12 | fill_in "comment_content", :with => "Hello world!"
13 | click_on "Post Comment"
14 | page.should have_content("Blast from the Past")
15 | page.should have_content("Hello world!")
16 | click_on "Reply"
17 | fill_in "comment_content", :with => "Hello back."
18 | click_on "Post Comment"
19 | page.should have_content("Hello back.")
20 | end
21 |
22 | it "send email to original authors when replying to comment" do
23 | comment = Factory(:comment)
24 | login
25 | visit episode_path(comment.episode, :view => "comments")
26 | click_on "Reply"
27 | fill_in "comment_content", :with => "Hello back."
28 | click_on "Post Comment"
29 | page.should have_content("Hello back.")
30 | last_email.to.should include(comment.user.email)
31 | end
32 |
33 | it "creates when banned" do
34 | login Factory(:user, :banned_at => Time.now)
35 | visit episode_path(Factory(:episode), :view => "comments")
36 | page.should have_content("banned")
37 | end
38 |
39 | it "updates a comment" do
40 | user = Factory(:user, :admin => true)
41 | login user
42 | episode = Factory(:episode, :name => "Blast from the Past")
43 | comment = Factory(:comment, :content => "Hello world!", :episode_id => episode.id)
44 | visit episode_path(episode, :view => "comments")
45 | click_on "Edit"
46 | fill_in "comment_content", :with => ""
47 | click_on "Update Comment"
48 | page.should have_content("Invalid Fields")
49 | fill_in "comment_content", :with => "Hello back."
50 | click_on "Update Comment"
51 | page.should have_content("Hello back.")
52 | comment.versions(true).size.should eq(2)
53 | comment.versions.last.whodunnit.to_i.should eq(user.id)
54 | end
55 |
56 | it "destroys a comment" do
57 | login Factory(:user, :admin => true)
58 | episode = Factory(:episode, :name => "Blast from the Past")
59 | Factory(:comment, :content => "Hello world!", :episode_id => episode.id)
60 | visit episode_path(episode, :view => "comments")
61 | click_on "Delete"
62 | page.should_not have_content("Hello world!")
63 | click_on "undo"
64 | page.should have_content("Hello world!")
65 | end
66 |
67 | it "lists and search recent comments" do
68 | login Factory(:user, :admin => true)
69 | Factory(:comment, :content => "Hello world!")
70 | Factory(:comment, :content => "Back to the Future", :site_url => "http://example.com")
71 | visit comments_path
72 | page.should have_content("Hello world!")
73 | page.should have_content("Back to the Future")
74 | fill_in "comment_search", :with => "Future"
75 | click_on "Search Comments"
76 | page.should_not have_content("Hello world!")
77 | page.should have_content("Back to the Future")
78 | end
79 | end
80 |
--------------------------------------------------------------------------------
/spec/requests/episodes_request_spec.rb:
--------------------------------------------------------------------------------
1 | require 'spec_helper'
2 |
3 | describe "Episodes request" do
4 | it "lists published" do
5 | Factory(:episode, :name => "Blast from the Past", :published_at => 2.days.ago)
6 | Factory(:episode, :name => "Back to the Future", :published_at => 2.days.from_now)
7 | visit episodes_path
8 | page.should have_content("Blast from the Past")
9 | page.should_not have_content("Back to the Future")
10 | end
11 |
12 | it "provides RSS feed of episodes" do
13 | Factory(:episode, :name => "Blast from the Past", :published_at => 2.days.ago)
14 | visit episodes_path(:format => :rss)
15 | page.should have_content("Blast from the Past")
16 | end
17 |
18 | it "has different views" do
19 | Factory(:episode, :name => "Blast from the Past", :description => "I am from 1960", :published_at => 2.days.ago)
20 | visit episodes_path
21 | page.should have_content("I am from 1960")
22 | click_on "List View"
23 | page.should_not have_content("I am from 1960")
24 | page.should have_content("Duration")
25 | click_on "Grid View"
26 | page.should_not have_content("I am from 1960")
27 | page.should_not have_content("Duration")
28 | end
29 |
30 | it "searches by name" do
31 | Factory(:episode, :name => "Blast from the Past")
32 | Factory(:episode, :name => "Back to the Future")
33 | visit episodes_path
34 | fill_in "search", :with => "Blast"
35 | click_on "Search Episodes"
36 | page.should have_content("Blast from the Past")
37 | page.should_not have_content("Back to the Future")
38 | click_on "x"
39 | page.should have_content("Blast from the Past")
40 | page.should have_content("Back to the Future")
41 | end
42 |
43 | it "filters by tag" do
44 | Factory(:episode, :name => "Blast from the Past", :tags => [Factory.build(:tag, :name => "Oldtimes")])
45 | Factory(:episode, :name => "Back to the Future")
46 | visit episodes_path
47 | click_on "Oldtimes"
48 | page.should have_content("Blast from the Past")
49 | page.should_not have_content("Back to the Future")
50 | click_on "x"
51 | page.should have_content("Blast from the Past")
52 | page.should have_content("Back to the Future")
53 | end
54 |
55 | it "contains show notes, comments, and similar episodes" do
56 | episode = Factory(:episode, :name => "Blast from the Past", :notes => "Show notes!", :position => 1)
57 | Factory(:comment, :content => "Hello world", :episode => episode)
58 | Factory(:episode, :name => "Star Wars", :position => 2)
59 | Factory(:episode, :name => "Past and Present", :position => 3)
60 | visit episodes_path
61 | click_on "Blast from the Past"
62 | page.should have_content("Blast from the Past")
63 | page.should have_content("Show notes!")
64 | page.should_not have_content("Hello world")
65 | click_on "1 Comment"
66 | page.should_not have_content("Show notes!")
67 | page.should have_content("Hello world")
68 | click_on "Similar Episodes"
69 | page.should_not have_content("Show notes!")
70 | page.should_not have_content("Hello world")
71 | page.should have_content("Past and Present")
72 | page.should_not have_content("Star Wars")
73 | click_on "Next Episode"
74 | page.should have_content("Star Wars")
75 | click_on "Previous Episode"
76 | page.should have_content("Blast from the Past")
77 | end
78 |
79 | it "redirects to episode when full permalink isn't used" do
80 | episode = Factory(:episode, :name => "Blast from the Past")
81 | visit episode_path("#{episode.position}-anything")
82 | page.current_path.should eq(episode_path("#{episode.position}-#{episode.permalink}"))
83 | end
84 |
85 | it "reports unauthorized access when attempting to create an episode as a normal user" do
86 | Factory(:episode, :name => "Blast from the Past", :published_at => 2.days.ago)
87 | visit new_episode_path
88 | page.should have_content("not authorized")
89 | end
90 |
91 | it "creates a new episode with default position" do
92 | FakeWeb.register_uri(:head, /.*/, :content_length => 123)
93 | login Factory(:user, :admin => true)
94 | visit episodes_path
95 | click_on "New Episode"
96 | click_on "Create"
97 | page.should have_content("Invalid Fields")
98 | fill_in "Name", :with => "Blast from the Past"
99 | fill_in "Duration", :with => "15:23"
100 | click_on "Create"
101 | page.current_path.should eq(episode_path(Episode.last))
102 | page.should have_content("Blast from the Past")
103 | page.should have_content("15 minutes")
104 | Episode.last.file_size("mp4").should == 123
105 | end
106 |
107 | it "edits an episode as admin" do
108 | FakeWeb.register_uri(:head, /.*/, :content_length => 123)
109 | login Factory(:user, :admin => true)
110 | episode = Factory(:episode, :name => "Blast from the Past")
111 | visit episode_path(episode)
112 | click_on "Edit"
113 | fill_in "Name", :with => ""
114 | click_on "Update"
115 | page.should have_content("Invalid Fields")
116 | fill_in "Name", :with => "Back to the Future"
117 | click_on "Update"
118 | page.current_path.should eq(episode_path(episode))
119 | page.should have_content("Back to the Future")
120 | end
121 |
122 | it "edits an episode show notes as moderator" do
123 | FakeWeb.register_uri(:head, /.*/, :content_length => 123)
124 | login Factory(:user, :moderator => true)
125 | episode = Factory(:episode)
126 | visit episode_path(episode)
127 | click_on "Edit"
128 | page.should_not have_content("Name")
129 | fill_in "Notes", :with => "Updating notes!"
130 | click_on "Update"
131 | page.should have_content("Updating notes!")
132 | episode.reload.file_size("mp4").should == 123
133 | end
134 |
135 | it "redirects /episodes/archive to episodes list" do
136 | visit "/episodes/archive"
137 | page.current_url.should eq(root_url(:view => "list"))
138 | end
139 | end
140 |
--------------------------------------------------------------------------------
/spec/requests/feedback_messages_request_spec.rb:
--------------------------------------------------------------------------------
1 | require 'spec_helper'
2 |
3 | describe "FeedbackMessages request" do
4 | before(:each) do
5 | ActionMailer::Base.deliveries = []
6 | end
7 |
8 | it "sends an email to feedback@railscasts.com when feedback is submitted" do
9 | visit feedback_path
10 | click_button "Send"
11 | page.should have_content("Invalid Fields")
12 | fill_in "Name", :with => "Foo"
13 | fill_in "Email Address", :with => "foo@example.com"
14 | fill_in "Message", :with => "Hello"
15 | click_button "Send"
16 | page.should have_content("Thank you for the feedback.")
17 | ActionMailer::Base.deliveries.count.should eq(1)
18 | end
19 |
20 | it "includes logged in user email and name" do
21 | login Factory(:user, :name => "Foo Test", :email => "footest@example.com")
22 | visit feedback_path
23 | find_by_id("feedback_message_name").value.should eq("Foo Test")
24 | find_by_id("feedback_message_email").value.should eq("footest@example.com")
25 | end
26 |
27 | it "does not send an email when filling out fake email field (honeypot)" do
28 | ActionMailer::Base.deliveries = []
29 | visit feedback_path
30 | fill_in "email", :with => "foo@example.com"
31 | fill_in "Name", :with => "Foo"
32 | fill_in "Email Address", :with => "foo@example.com"
33 | fill_in "Message", :with => "Hello"
34 | click_button "Send"
35 | page.should have_content("caught")
36 | ActionMailer::Base.deliveries.count.should eq(0)
37 | end
38 | end
39 |
--------------------------------------------------------------------------------
/spec/requests/info_request_spec.rb:
--------------------------------------------------------------------------------
1 | require 'spec_helper'
2 |
3 | describe "Info request" do
4 | it "has about page" do
5 | visit about_path
6 | page.should have_content("About RailsCasts")
7 | end
8 | end
9 |
--------------------------------------------------------------------------------
/spec/requests/users_request_spec.rb:
--------------------------------------------------------------------------------
1 | require 'spec_helper'
2 |
3 | describe "Users request" do
4 | it "shows profile" do
5 | user = Factory(:user, :name => "Jack Sparrow", :github_username => "jsparrow")
6 | visit user_path(user)
7 | page.should have_content(user.name)
8 | page.should have_content(user.github_username)
9 | page.should_not have_content("Edit Profile")
10 | end
11 |
12 | it "edits current user" do
13 | user = Factory(:user)
14 | login user
15 | visit user_path(user)
16 | page.should have_content("This is your profile.")
17 | click_on "Edit Profile"
18 | fill_in "Name", :with => "Leonardo"
19 | uncheck "user_email_on_reply"
20 | click_on "Update Profile"
21 | page.should have_content("Successfully updated profile")
22 | page.should have_content("Leonardo")
23 | user.reload.email_on_reply.should be_false
24 | end
25 |
26 | it "logs out current user" do
27 | user = Factory(:user)
28 | login user
29 | visit logout_path
30 | visit user_path(user)
31 | page.should_not have_content("This is your profile.")
32 | end
33 |
34 | it "logs in existing user and redirects to return_to parameter" do
35 | user = Factory(:user)
36 | OmniAuth.config.add_mock(:github, "uid" => user.github_uid)
37 | visit login_path(:return_to => user_path(user))
38 | page.should have_content("This is your profile.")
39 | end
40 |
41 | it "logs in unknown profile and creates user" do
42 | User.count.should be_zero
43 | OmniAuth.config.add_mock(:github, "uid" => "54321")
44 | visit login_path
45 | page.current_path.should eq("/")
46 | User.count.should eq(1)
47 | User.last.github_uid.should eq("54321")
48 | end
49 |
50 | it "bans user as moderator" do
51 | user = Factory(:user, :moderator => true)
52 | login user
53 | bad_user = Factory(:user)
54 | comment = Factory(:comment, :user => bad_user)
55 | visit episode_path(comment.episode, :view => "comments")
56 | click_on "Ban User"
57 | bad_user.reload.should be_banned
58 | bad_user.comments.size.should eq(0)
59 | end
60 |
61 | it "unsubscribe a user from comment replies" do
62 | user = Factory(:user)
63 | visit unsubscribe_path(user.generated_unsubscribe_token)
64 | page.should have_content("unsubscribed")
65 | user.reload.email_on_reply.should be_false
66 | end
67 | end
68 |
--------------------------------------------------------------------------------
/spec/spec_helper.rb:
--------------------------------------------------------------------------------
1 | if ENV['COVERAGE']
2 | require "simplecov"
3 | SimpleCov.start "rails"
4 | end
5 |
6 | # This file is copied to spec/ when you run 'rails generate rspec:install'
7 | ENV["RAILS_ENV"] ||= 'test'
8 | require File.expand_path("../../config/environment", __FILE__)
9 | require "rspec/rails"
10 | require "capybara/rspec"
11 |
12 | # Capybara.javascript_driver = :webkit
13 |
14 | FakeWeb.allow_net_connect = false
15 |
16 | # Requires supporting ruby files with custom matchers and macros, etc,
17 | # in spec/support/ and its subdirectories.
18 | Dir[Rails.root.join("spec/support/**/*.rb")].each {|f| require f}
19 |
20 | OmniAuth.config.test_mode = true
21 | OmniAuth.config.mock_auth[:github] = {
22 | 'uid' => '12345',
23 | "user_info" => {
24 | "email" => "foo@example.com",
25 | "nickname" => "foobar",
26 | "name" => "Foo Bar"
27 | }
28 | }
29 |
30 | RSpec.configure do |config|
31 | # == Mock Framework
32 | #
33 | # If you prefer to use mocha, flexmock or RR, uncomment the appropriate line:
34 | #
35 | # config.mock_with :mocha
36 | # config.mock_with :flexmock
37 | # config.mock_with :rr
38 |
39 | # Remove this line if you're not using ActiveRecord or ActiveRecord fixtures
40 | # config.fixture_path = "#{::Rails.root}/spec/fixtures"
41 |
42 | # If you're not using ActiveRecord, or you'd prefer not to run each of your
43 | # examples within a transaction, remove the following line or assign false
44 | # instead of true.
45 | config.use_transactional_fixtures = false
46 |
47 | config.before(:suite) do
48 | DatabaseCleaner.strategy = :transaction
49 | DatabaseCleaner.clean_with(:truncation)
50 | end
51 |
52 | config.before(:each) do
53 | FakeWeb.clean_registry
54 | reset_email
55 | if example.metadata[:js]
56 | DatabaseCleaner.strategy = :truncation
57 | else
58 | DatabaseCleaner.start
59 | end
60 | end
61 |
62 | config.after(:each) do
63 | DatabaseCleaner.clean
64 | if example.metadata[:js]
65 | DatabaseCleaner.strategy = :transaction
66 | end
67 | end
68 |
69 | config.include AuthMacros
70 | config.include MailerMacros
71 | end
72 |
73 |
74 | # quick hack to get Rack to be quiet about "warning: regexp match /.../n against to UTF-8 string" until we upgrade to Rails 3.1 with Rack 1.3
75 | module Rack
76 | module Utils
77 | def escape(s)
78 | CGI.escape(s.to_s)
79 | end
80 | def unescape(s)
81 | CGI.unescape(s)
82 | end
83 | end
84 | end
85 |
--------------------------------------------------------------------------------
/spec/support/auth_macros.rb:
--------------------------------------------------------------------------------
1 | module AuthMacros
2 | def login(user = nil)
3 | user ||= Factory(:user)
4 | OmniAuth.config.add_mock(:github, "uid" => user.github_uid)
5 | visit login_path
6 | @_current_user = user
7 | end
8 |
9 | def current_user
10 | @_current_user
11 | end
12 | end
13 |
--------------------------------------------------------------------------------
/spec/support/mailer_macros.rb:
--------------------------------------------------------------------------------
1 | module MailerMacros
2 | def last_email
3 | ActionMailer::Base.deliveries.last
4 | end
5 |
6 | def reset_email
7 | ActionMailer::Base.deliveries = []
8 | end
9 |
10 | def email_count
11 | ActionMailer::Base.deliveries.size
12 | end
13 | end
14 |
--------------------------------------------------------------------------------
/tmp/.gitignore:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ryanb/railscasts/010f1927c9ccb9604d0af1c6326419bd5371b56c/tmp/.gitignore
--------------------------------------------------------------------------------
/vendor/.gitignore:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ryanb/railscasts/010f1927c9ccb9604d0af1c6326419bd5371b56c/vendor/.gitignore
--------------------------------------------------------------------------------
/vendor/plugins/.gitkeep:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ryanb/railscasts/010f1927c9ccb9604d0af1c6326419bd5371b56c/vendor/plugins/.gitkeep
--------------------------------------------------------------------------------
21 | 
24 | watch on iTunes
25 | 
28 | follow on Twitter
29 | 
32 | follow on Facebook
33 | 
36 | subscribe to RSS feed
37 | 