storytime 1.2.0 → 2.0.0

data/spec/features/dashboard/pages_spec.rb

@@ -5,76 +5,99 @@ describe "In the dashboard, Pages" do
     login_admin
   end
 
-  it "lists pages" do
-    post = FactoryGirl.create(:post)
-    3.times{ FactoryGirl.create(:page) }
-    visit url_for([:dashboard, Storytime::Post, type: Storytime::Page.type_name])
-    
-    Storytime::Page.all.each do |p|
-      page.should have_link(p.title, href: url_for([:edit, :dashboard, p, only_path: true]))
-      page.should_not have_content(p.content)
+  describe "index" do
+    before do 
+      3.times{ FactoryGirl.create(:page, site: current_site) }
+      3.times{ FactoryGirl.create(:page, published_at: nil, site: current_site) }
+    end
+
+    let!(:other_site_page){ FactoryGirl.create(:page) }
+
+    it "lists draft pages" do
+      visit dashboard_pages_path
+      
+      current_site.pages.each do |p|
+        expect(page).to have_link_to_post(p) if p.published_at.nil?
+        expect(page).not_to have_link_to_post(p) if p.published_at.present?
+        expect(page).not_to have_content(p.content)
+      end
+
+      expect(page).not_to have_link_to_post(other_site_page)
     end
 
-    page.should_not have_link(post.title, href: url_for([:edit, :dashboard, post, only_path: true]))
+    it "lists published pages" do
+      visit dashboard_pages_path(published: true)
+      
+      # need the type designation so Blogs, which are Page subclasses, don't show up in the query
+      current_site.pages.where(type: "Storytime::Page").each do |p|
+        expect(page).not_to have_link_to_post(p) if p.published_at.nil?
+        expect(page).to have_link_to_post(p) if p.published_at.present?
+        expect(page).not_to have_content(p.content)
+      end
+
+      expect(page).not_to have_link_to_post(other_site_page)
+    end
   end
   
-  it "creates a page" do
-    Storytime::Page.count.should == 0
-    media = FactoryGirl.create(:media)
+  it "creates a page", js: true do
+    page_count = Storytime::Page.count
+
+    visit new_dashboard_page_path
 
-    visit url_for([:new, :dashboard, :post, type: Storytime::Page.type_name, only_path: true])
-    fill_in "post_title", with: "The Story"
-    fill_in "post_draft_content", with: "It was a dark and stormy night..."
-    find("#featured_media_id").set media.id
+    find('#post-title-input').set("The Page")
+    find('#medium-editor-post').set("The content of my page")
     
+    click_link "Save / Publish"
     click_button "Save Draft"
     
-    page.should have_content(I18n.t('flash.posts.create.success'))
-    Storytime::Page.count.should == 1
+    expect(page).to have_content(I18n.t('flash.posts.create.success'))
+    expect(Storytime::Page.count).to eq(page_count + 1)
 
     pg = Storytime::Page.last
-    pg.title.should == "The Story"
-    pg.draft_content.should == "It was a dark and stormy night..."
-    pg.user.should == current_user
-    pg.should_not be_published
-    pg.type.should == "Storytime::Page"
-    pg.featured_media.should == media
+    expect(pg.title).to eq("The Page")
+    expect(pg.draft_content).to eq("<p>The content of my page</p>")
+    expect(pg.user).to eq(current_user)
+    expect(pg.site).to eq(current_site)
+    expect(pg.type).to eq("Storytime::Page")
+    expect(pg.slug).to eq("The Page".parameterize)
+    expect(pg).to_not be_published
   end
 
-  it "updates a page" do
-    pg = FactoryGirl.create(:page, published_at: nil)
+  it "updates a page", js: true do
+    pg = FactoryGirl.create(:page, site: current_site, published_at: nil)
     original_creator = pg.user
-    Storytime::Page.count.should == 1
+    page_count = Storytime::Page.count
+    
+    visit edit_dashboard_page_path(pg)
+    find('#post-title-input').set("The Story")
+    find('#medium-editor-post').set("It was a dark and stormy night...")
     
-    visit url_for([:edit, :dashboard, pg])
-    fill_in "post_title", with: "The Story"
-    fill_in "post_draft_content", with: "It was a dark and stormy night..."
+    click_link "advanced-settings-panel-toggle"
     click_button "Save Draft"
     
-    page.should have_content(I18n.t('flash.posts.update.success'))
-    Storytime::Page.count.should == 1
+    expect(page).to have_content(I18n.t('flash.posts.update.success'))
+    expect(Storytime::Page.count).to eq(page_count)
 
     pg = Storytime::Page.last
-    pg.title.should == "The Story"
-    pg.draft_content.should == "It was a dark and stormy night..."
-    pg.user.should == original_creator
-    pg.should_not be_published
-    pg.type.should == "Storytime::Page"
+    expect(pg.title).to eq("The Story")
+    expect(pg.draft_content).to eq("<p>It was a dark and stormy night...</p>")
+    expect(pg.user).to eq(original_creator)
+    expect(pg.type).to eq("Storytime::Page")
+    expect(pg).to_not be_published
   end
 
   it "deletes a page", js: true do
-    3.times{|i| FactoryGirl.create(:page) }
-    expect(Storytime::Page.count).to eq(3)
+    storytime_page = FactoryGirl.create(:page, site: current_site)
+    page_count = Storytime::Page.count
 
-    storytime_page = Storytime::Page.first
-    visit url_for([:edit, :dashboard, storytime_page, type: Storytime::Page.type_name, only_path: true])
+    visit edit_dashboard_page_path(storytime_page)
     
+    click_button "post-utilities"
     click_link "Delete"
 
-    expect { storytime_page.reload }.to raise_error
-
     expect(page).to_not have_content(storytime_page.title)
-    expect(Storytime::Page.count).to eq(2)
+    expect { storytime_page.reload }.to raise_error
+    expect(Storytime::Page.count).to eq(page_count - 1)
   end
   
 end

data/spec/features/dashboard/posts_spec.rb

@@ -1,121 +1,143 @@
 require 'spec_helper'
 
 describe "In the dashboard, Posts" do
-  before{ login_admin }
+  before do
+    login_admin
+  end
 
-  it "lists posts" do
-    3.times{ FactoryGirl.create(:post) }
+  it "lists draft posts" do
+    blog = @current_site.blogs.first
+    3.times{ FactoryGirl.create(:post, blog: blog, site: @current_site, published_at: nil) }
+    3.times{ FactoryGirl.create(:post, blog: blog, site: @current_site, published_at: 2.hours.ago) }
     FactoryGirl.create(:post)
     static_page = FactoryGirl.create(:page)
-    visit url_for([:dashboard, Storytime::Post, type: Storytime::BlogPost.type_name, only_path: true])
+
+    visit url_for([storytime, :dashboard, blog, :blog_page_post_index, only_path: true])
     
-    within "#list" do
-      Storytime::Post.primary_feed.each do |p|
-        expect(page).to have_content(p.title)
+    within "#main" do
+      blog.posts.each do |p|
+        expect(page).to have_content(p.title) if p.published_at.nil?
+        expect(page).not_to have_content(p.title) if p.published_at.present?
       end
 
       expect(page).not_to have_content(static_page.title)
     end
   end
   
-  it "creates a post" do
-    Storytime::BlogPost.count.should == 0
+  it "creates a post", js: true do
+    post_count = Storytime::BlogPost.count
     media = FactoryGirl.create(:media)
+    Rails.logger.warn "==> STARTING CREATE POST"
+    visit url_for([:new, :dashboard, @current_site.blogs.first, :blog_post, only_path: true])
 
-    visit url_for([:new, :dashboard, :post])
-    fill_in "post_title", with: "The Story"
-    fill_in "post_excerpt", with: "It was a dark and stormy night..."
-    fill_in "post_draft_content", with: "It was a dark and stormy night..."
-    find("#featured_media_id").set media.id
-    click_button "Save Draft"
+    find('#post-title-input').set("The Story")
+    find('#medium-editor-post').set("It was a dark and stormy night...")
+    
+    click_link "Save / Publish"
+
+    fill_in "blog_post_excerpt", with: "It was a dark and stormy night..."
+    find("#featured_media_id", visible: false).set media.id
+    
+    click_button "save-draft-submit"
     
-    page.should have_content(I18n.t('flash.posts.create.success'))
-    Storytime::BlogPost.count.should == 1
+    expect(page).to have_content(I18n.t('flash.posts.create.success'))
+    expect(Storytime::BlogPost.count).to eq(post_count + 1)
 
     post = Storytime::BlogPost.last
-    post.title.should == "The Story"
-    post.draft_content.should == "It was a dark and stormy night..."
-    post.user.should == current_user
-    post.should_not be_published
-    post.type.should == "Storytime::BlogPost"
-    post.featured_media.should == media
+    expect(post.title).to eq("The Story")
+    expect(post.draft_content).to eq("<p>It was a dark and stormy night...</p>")
+    expect(post.user).to eq(current_user)
+    expect(post.type).to eq("Storytime::BlogPost")
+    expect(post.featured_media).to eq(media)
+    expect(post).to_not be_published
   end
 
   it "saves a post when previewing a new post", js: true do
-    Storytime::BlogPost.count.should == 0
+    post_count = Storytime::BlogPost.count
 
-    visit url_for([:new, :dashboard, :post, only_path: true])
-    fill_in "post_title", with: "Snow Crash"
-    fill_in "post_excerpt", with: "The Deliverator belongs to an elite order, a hallowed sub-category."
+    visit url_for([:new, :dashboard, @current_site.blogs.first, :blog_post, only_path: true])
 
-    # Use find(".note-editable").set instead of fill_in "post_draft_content" because of Summernote (js)
-    find(".note-editable").set "The Deliverator belongs to an elite order, a hallowed sub-category."
+    find('#post-title-input').set("Snow Crash")
+    find('#medium-editor-post').set("It was a dark and stormy night...")
+    find('#blog_post_excerpt', visible: false).set("It was a dark and stormy night...")
+    
     click_button "Preview"
     
-    page.should have_content(I18n.t('flash.posts.create.success'))
-    Storytime::BlogPost.count.should == 1
+    expect(page).to have_content(I18n.t('flash.posts.create.success'))
+    expect(Storytime::BlogPost.count).to eq(post_count + 1)
 
     post = Storytime::BlogPost.last
-    post.title.should == "Snow Crash"
-    post.draft_content.should == "<p>The Deliverator belongs to an elite order, a hallowed sub-category.</p>"
-    post.user.should == current_user
-    post.should_not be_published
-    post.type.should == "Storytime::BlogPost"
+    expect(post.title).to eq("Snow Crash")
+    expect(post.draft_content).to eq("<p>It was a dark and stormy night...</p>")
+    expect(post.user).to eq(current_user)
+    expect(post.type).to eq("Storytime::BlogPost")
+    expect(post).to_not be_published
   end
 
   it "autosaves a post when editing", js: true do
-    post = FactoryGirl.create(:post, published_at: nil, title: "A Scandal in Bohemia",
+    blog = @current_site.blogs.first
+    post = FactoryGirl.create(:post, blog: blog, site: @current_site, published_at: nil,
+                              title: "A Scandal in Bohemia",
                               draft_content: "To Sherlock Holmes she was always the woman.")
+
     original_creator = post.user
-    Storytime::BlogPost.count.should == 1
+    post_count = Storytime::BlogPost.count
 
-    post.autosave.should == nil
+    expect(post.autosave).to be_nil
 
     visit url_for([:edit, :dashboard, post, only_path: true])
 
-    page.execute_script "Storytime.instance.editor.autosavePostForm()"
+    find('#medium-editor-post').set("Some content to autosave")
+    
+    page.execute_script "Storytime.instance.editor.editor.autosavePostForm()"
+
+    expect(page).to have_content("Draft saved at")
 
     visit url_for([:edit, :dashboard, post, only_path: true])
 
-    page.should have_content("View the autosave.")
+    expect(page).to have_content("View the autosave")
 
     post.reload
     expect(post.autosave).not_to be_nil
-    expect(post.autosave.content).to eq("To Sherlock Holmes she was always the woman.")
+    expect(post.autosave.content).to eq("<p>Some content to autosave</p>")
+    expect(Storytime::BlogPost.count).to eq(post_count)
   end
 
-  it "updates a post" do
-    post = FactoryGirl.create(:post, published_at: nil)
+  it "updates a post", js: true do
+    blog = @current_site.blogs.first
+    post = FactoryGirl.create(:post, blog: blog, site: @current_site, published_at: nil)
     original_creator = post.user
-    Storytime::BlogPost.count.should == 1
+    post_count = Storytime::BlogPost.count
+    # page.driver.debug
 
     visit url_for([:edit, :dashboard, post, only_path: true])
-    fill_in "post_title", with: "The Story"
-    fill_in "post_draft_content", with: "It was a dark and stormy night..."
+    find('#post-title-input').set("The Story")
+    find('#medium-editor-post').set("It was a dark and stormy night...")
+    click_link "advanced-settings-panel-toggle"
     click_button "Save Draft"
-    
-    page.should have_content(I18n.t('flash.posts.update.success'))
-    Storytime::BlogPost.count.should == 1
 
-    post = Storytime::BlogPost.last
-    post.title.should == "The Story"
-    post.draft_content.should == "It was a dark and stormy night..."
-    post.user.should == original_creator
-    post.should_not be_published
+    expect(page).to have_content(I18n.t('flash.posts.update.success'))
+    expect(Storytime::BlogPost.count).to eq(post_count)
+
+    post = post.reload
+    post.draft_content = nil # clear the cached copy of draft_content so it reloads
+    expect(post.title).to eq("The Story")
+    expect(post.draft_content).to eq("<p>It was a dark and stormy night...</p>")
+    expect(post.user).to eq(original_creator)
+    expect(post).to_not be_published
   end
 
   it "deletes a post", js: true do
-    3.times{|i| FactoryGirl.create(:post) }
+    blog = @current_site.blogs.first
+    3.times{ FactoryGirl.create(:post, blog: blog, site: @current_site) }
     expect(Storytime::BlogPost.count).to eq(3)
 
     post = Storytime::BlogPost.first
     visit url_for([:edit, :dashboard, post, only_path: true])
     
-    click_link "Delete"
-
-    expect { post.reload }.to raise_error
-
-    expect(page).to_not have_content(post.title)
-    expect(Storytime::Post.count).to eq(2)
+    expect{
+      click_button "post-utilities"
+      click_link "Delete"
+    }.to change(Storytime::BlogPost, :count).by(-1)
   end
 end

data/spec/features/dashboard/sites_spec.rb

@@ -3,41 +3,46 @@ require 'spec_helper'
 describe "In the dashboard, Sites" do
 
   it "creates a site" do
-    login FactoryGirl.create(:admin), true
-    Storytime::Site.count.should == 0
-
+    login FactoryGirl.create(:user), true
+    expect(Storytime::Site.count).to eq(0)
+    
     visit new_dashboard_site_path
+
     fill_in "site_title", with: "The Site"
-    click_button "Create Site"
+    fill_in "site_custom_domain", with: "example.lvh.me"
+    fill_in "site_subscription_email_from", with: "test@example.com"
+    
+    click_button "Save"
+
+    # since creating a site redirects you to a new domain, you are not logged in
+    fill_in "user_email", with: current_user.email
+    fill_in "user_password", with: current_user.password
+    click_on "Log in"
     
-    page.should have_content(I18n.t('flash.sites.create.success'))
-    Storytime::Site.count.should == 1
+    expect(page).to have_content("Pages")
+    expect(Storytime::Site.count).to eq(1)
 
-    page = Storytime::Site.last
-    page.title.should == "The Site"
+    site = Storytime::Site.last
+    expect(site.title).to eq("The Site")
+    expect(site.custom_domain).to eq("example.lvh.me")
+    expect(site.subscription_email_from).to eq("test@example.com")
   end
 
   context "as a logged in user" do
     before{ login_admin }
 
-    it "updates a site" do
-      Storytime::Site.count.should == 1
+    it "updates a site", js: true do
+      site = Storytime::Site.last
 
-      visit edit_dashboard_site_path(current_site)
+      visit storytime.dashboard_path
+      click_link "utility-menu-toggle"
+      click_link "site-settings-link"
       fill_in "site_title", with: "The Site's New Name"
-      click_button "Update Site"
+      click_button "Save"
       
-      page.should have_content(I18n.t('flash.sites.update.success'))
-      Storytime::Site.count.should == 1
-
-      s = Storytime::Site.last
-      s.title.should == "The Site's New Name"
-    end
-
-    it "new redirects to edit if a site already exists" do
-      visit new_dashboard_site_path
-      page.should have_content("Site Settings")
-      page.should have_content("Permissions")
+      expect(page).to have_content("Your changes were saved successfully")
+      site.reload
+      expect(site.title).to eq "The Site's New Name"
     end
   end
 end

data/spec/features/dashboard/snippets_spec.rb

@@ -5,63 +5,63 @@ describe "In the dashboard, Snippets" do
     login_admin
   end
 
-  it "lists snippets" do
-    3.times{ FactoryGirl.create(:snippet) }
-    visit url_for([:dashboard, Storytime::Snippet])
+  it "lists snippets", js: true do
+    3.times{ FactoryGirl.create(:snippet, site: @current_site) }
+    visit storytime.dashboard_url
+    find("#snippets-link").trigger('click')
     
-    Storytime::Snippet.all.each do |s|
-      expect(page).to have_link(s.name, href: url_for([:edit, :dashboard, s, only_path: true]))
-      expect(page).to_not have_content(s.content)
+    within "#storytime-modal" do
+      Storytime::Snippet.all.each do |s|
+        expect(page).to have_link(s.name, href: url_for([:edit, :dashboard, s, only_path: true]))
+        expect(page).to_not have_content(s.content)
+      end
     end
   end
   
-  it "creates a snippet" do
-    expect(Storytime::Snippet.count).to eq(0)
+  it "creates a snippet", js: true do
+    visit storytime.dashboard_url
+    find("#snippets-link").trigger('click')
+    click_link "new-snippet-link"
 
-    visit url_for([:new, :dashboard, :snippet, only_path: true])
-    fill_in "snippet_name", with: "jumbotron-text"
-    fill_in "snippet_content", with: "Hooray Writing!"
-    
-    click_button "Create Snippet"
-    
-    expect(page).to have_content(I18n.t('flash.snippets.create.success'))
-    expect(Storytime::Snippet.count).to eq(1)
+    within "#storytime-modal" do
+      fill_in "snippet_name", with: "jumbotron-text"
+      find("#medium-editor-snippet").set("Hooray Writing!")
+      click_button "Save"
+    end
 
-    snippet = Storytime::Snippet.last
-    expect(snippet.name).to eq("jumbotron-text")
-    expect(snippet.content).to eq("Hooray Writing!")
+    within "#storytime-modal" do
+      expect(page).to have_content "jumbotron-text"
+    end
   end
 
-  it "updates a snippet" do
-    snippet = FactoryGirl.create(:snippet)
-    expect(Storytime::Snippet.count).to eq(1)
-    
-    visit url_for([:edit, :dashboard, snippet])
-    fill_in "snippet_name", with: "new-name"
-    fill_in "snippet_content", with: "It was a dark and stormy night..."
-    click_button "Update Snippet"
-    
-    expect(page).to have_content(I18n.t('flash.snippets.update.success'))
-    expect(Storytime::Snippet.count).to eq(1)
+  it "updates a snippet", js: true do
+    snippet = FactoryGirl.create(:snippet, site: @current_site, content: "Test")
 
-    snippet = Storytime::Snippet.last
-    expect(snippet.name).to eq("new-name")
-    expect(snippet.content).to eq("It was a dark and stormy night...")
-  end
+    visit storytime.dashboard_url
+    find("#snippets-link").trigger('click')
 
-  it "deletes a snippet" do
-    3.times{|i| FactoryGirl.create(:snippet) }
-    expect(Storytime::Snippet.count).to eq(3)
+    click_link "edit-snippet-#{snippet.id}"
 
-    snippet = Storytime::Snippet.first
-    visit url_for([:edit, :dashboard, snippet, only_path: true])
+    fill_in "snippet_name", with: "new-name"
+    find("#medium-editor-snippet").set("It was a dark and stormy night...")
+    click_button "Save"
+
+    within "#storytime-modal" do
+      expect(page).to have_content "new-name"
+    end
+  end
 
-    click_link "Delete"
+  it "deletes a snippet", js: true do
+    snippet = FactoryGirl.create :snippet, site: @current_site
 
-    expect { snippet.reload }.to raise_error
+    visit storytime.dashboard_url
+    find("#snippets-link").trigger('click')
 
-    expect(page).to_not have_content(snippet.name)
-    expect(Storytime::Snippet.count).to eq(2)
+    find("#snippet_#{snippet.id}").hover()
+    click_link "delete_snippet_#{snippet.id}"
+    
+    within "#storytime-modal" do
+      expect(page).to_not have_content snippet.name
+    end
   end
-  
 end

data/spec/features/dashboard/subscription_spec.rb

@@ -5,48 +5,56 @@ describe "In the dashboard, Subscriptions" do
     login_admin
   end
 
-  it "lists subscriptions" do
-    3.times{ FactoryGirl.create(:subscription) }
-    visit url_for([:dashboard, Storytime::Subscription])
+  it "lists subscriptions", js: true do
+    3.times{ FactoryGirl.create(:subscription, site: @current_site) }
+    visit storytime.dashboard_path
+    click_link "utility-menu-toggle"
+    click_link "subscriptions-link"
+    # wait_for_ajax
 
     Storytime::Subscription.all.each do |s|
-      expect(page).to have_link("Edit", href: url_for([:edit, :dashboard, s]))  
+      expect(page).to have_content s.email
     end
   end
 
-  it "creates a subscription" do
-    expect(Storytime::Subscription.count).to eq(0)
+  it "creates a subscription", js: true do
+    visit storytime.dashboard_path
+    click_link "utility-menu-toggle"
+    click_link "subscriptions-link"
+    # wait_for_ajax
+    click_link "new-subscription-link"
+    # wait_for_ajax
 
-    visit url_for([:new, :dashboard, :subscription, only_path: true])
     fill_in "subscription_email", with: "some_random_email@example.com"
-
-    click_button "Create Subscription"
-
-    expect(page).to have_content(I18n.t('flash.subscriptions.create.success'))
-    expect(Storytime::Subscription.count).to eq(1)
-
-    subscription = Storytime::Subscription.last
-
-    expect(subscription.email).to eq("some_random_email@example.com")
-    expect(subscription.token).to_not eq(nil)
+    click_button "Save"
+      
+    within "#storytime-modal" do
+      expect(page).to have_content "some_random_email@example.com"
+    end
   end
 
-  it "updates a subscription" do
-    subscription = FactoryGirl.create(:subscription)
+  it "updates a subscription", js: true do
+    subscription = FactoryGirl.create(:subscription, site: @current_site)
 
     expect(Storytime::Subscription.count).to eq(1)
     expect(subscription.subscribed?).to eq(true)
 
-    visit url_for([:edit, :dashboard, subscription])
-    fill_in "subscription_email", with: "johndoe@example.com"
-    uncheck "subscription_subscribed"
-    click_button "Update Subscription"
-
-    expect(page).to have_content(I18n.t('flash.subscriptions.update.success'))
+    visit storytime.dashboard_path
+    click_link "utility-menu-toggle"
+    click_link "subscriptions-link"
+    
+    within "#storytime-modal" do
+      click_link "edit-subscription-#{subscription.id}"
+    end
 
-    subscription.reload
+    within "#storytime-modal" do
+      fill_in "subscription_email", with: "johndoe@example.com"
+      uncheck "subscription_subscribed"
+      click_button "Save"
+    end
 
-    expect(subscription.email).to eq("johndoe@example.com")
-    expect(subscription.subscribed?).to eq(false)
+    within "#storytime-modal" do 
+      expect(page).to have_content "johndoe@example.com"
+    end
   end
 end