path: root/test/controllers/nodes_controller_test.rb

require 'test_helper'

class NodesControllerTest < ActionController::TestCase

  def test_get_index
    Node.root.descendants.delete_all
    test_node = Node.root.children.create :slug => "foo"
    login_as :quentin
    get :index
    assert_response :success
  end
  
  def test_new
    login_as :quentin
    get :new
    assert_response :success
  end
  
  test "create generic node with parent_id provided" do
    login_as :quentin
    before_count = Node.count
    post(
      :create,
      params: {
        :kind => "generic",
        :parent_id => Node.root.id,
        :title => "Hello Spaceboy"
      }
    )
    assert_response :redirect
    assert_equal before_count + 1, Node.count
    assert_equal "hello-spaceboy", Node.last.slug
    assert_equal Node.last.parent_id, Node.root.id
    assert_equal 1, Node.last.level
  end
 
  test "create update node" do
    login_as :quentin
    post(
      :create,
      params: {
        :kind => "update",
        :title => "Hello Spaceboy"
      }
    )
    assert_response :redirect
  end
  
  test "create top level node" do
    login_as :quentin
    before_count = Node.count
    post(
      :create,
      params: {
        :kind => "top_level",
        :title => "Hello My Spaceboy"
      }
    )
    assert_response :redirect
    assert_equal before_count + 1, Node.count
    expected = "hello-my-spaceboy"
    assert_equal expected, Node.last.unique_name
    assert_equal 1, Node.last.level
  end
  
  test "creating a top_level node without a title should not work" do
    login_as :quentin
    
    assert_no_difference "Node.count" do
      post(:create, params: { :kind => "top_level" } )
    end
  end
  
  test "creating a generic node without a parent_id should not work" do
    login_as :quentin
    
    assert_no_difference "Node.count" do
      post(:create, params: { :kind => "generic" } )
    end
  end
  
  test "editing a node" do
    login_as :quentin
    
    node = Node.find_by_unique_name("fourth_child")
    node.pages.create
    node.draft = node.pages.last
    node.save
    
    assert_equal 1, node.pages.length
    
    draft = node.find_or_create_draft( User.first )
    draft.title = "Hello"
    draft.body = "World"
    draft.save
    node.publish_draft!
    
    get :edit, params: { :id => node.id }
    assert_response :success
    assert_select("#page_title[value='Hello']")
    assert_select("#page_body", "World")
    
    node.reload
    assert_equal 2, node.pages.length
    assert_equal "Hello", node.find_or_create_draft( User.first ).title
    assert_equal "World", node.find_or_create_draft( User.first ).body
  end
  
  test "editing a locked node raises LockedByAnotherUser Exception" do
    login_as :quentin
    
    node = create_node_with_draft
    node.lock_owner = User.last
    node.save
    
    assert node.locked?
    
    get :edit, params: { :id => node.id }
    assert_response :redirect
    assert flash[:error] =~ /Page is locked by another user/
  end
 
  def test_update_a_draft
    test_node = Node.root.children.create! :slug => "test_node"
    login_as :quentin
    put :update, params: { :id => test_node.id, :page => {:title => "Hello", :body => "There"} }
    test_node.reload
    assert_equal "Hello", test_node.draft.title
    assert_equal "There", test_node.draft.body
  end
  
  def test_update_a_draft_with_changing_the_template
    test_node = Node.root.children.create! :slug => "test_node"

    login_as :quentin
    put :update, params: {
      :id => test_node.id,
      :page => {
        :title => "Hello",
        :body => "There",
        :template_name => "Foobar"
      }
    }

    put :publish, params: { :id => test_node.id }
    test_node.reload
    assert_equal "Hello", test_node.head.title
    assert_equal "There", test_node.head.body
    assert_equal "Foobar", test_node.head.template_name
  end
  
  test "publish draft with staged_slug unqueal slug" do
    login_as :quentin
    
    test_node = Node.root.children.create! :slug => "test_node", :staged_slug => "peter_pan"
    
    put :publish, params: { :id => test_node.id }
    
    test_node.reload
    assert_equal "peter_pan", test_node.slug
    assert_equal "peter_pan", test_node.unique_name
  end
  
  test "publish draft with staged_slug with more levels of nodes" do
    login_as :quentin

    test_node = Node.root.children.create! :slug => "test_node", :staged_slug => "peter_pan"
    test_node2 = test_node.children.create! :slug => "test_node2"

    put :publish, params: { :id => test_node.id }
    
    test_node.reload; test_node2.reload
    assert_equal "peter_pan/test_node2", test_node2.unique_name
    assert_equal "peter_pan", test_node.unique_name
  end
 
  test "publish draft with staged_parent_id" do
    login_as :quentin

    parent = Node.root.children.create! :slug => "parent"
    test_node = Node.root.children.create! :slug => "test_node", :staged_parent_id => parent.id
    test_node2 = test_node.children.create! :slug => "test_node2"

    put :publish, params: { :id => test_node.id }

    test_node.reload; test_node2.reload
    assert_equal "parent/test_node", test_node.unique_name
    assert_equal "parent/test_node/test_node2", test_node2.unique_name
  end
  
  test "publish draft with staged_parent_id and staged_slug" do
    login_as :quentin
    
    parent = Node.root.children.create! :slug => "parent"
    
    test_node = Node.root.children.create!(
      :slug => "test_node", 
      :staged_parent_id => parent.id,
      :staged_slug => "peter_pan"
    )
    
    test_node2 = test_node.children.create! :slug => "test_node2"
    
    put :publish, params: { :id => test_node.id }
    
    test_node.reload; test_node2.reload
    assert_equal "parent/peter_pan", test_node.unique_name
    assert_equal "parent/peter_pan/test_node2", test_node2.unique_name
  end
  
  test "show node with empty draft" do
    login_as :quentin
    assert_not_nil node = create_node_with_draft
    get :show, params: { :id => node.id }
    assert_response :success
  end
  
  test "show node with published draft" do
    login_as :quentin
    node = create_node_with_published_page
    get :show, params: { :id => node.id }
    assert_response :success
    assert_select "td", :text => "Test", :count =>  3
  end
  
  test "unlocking a locked node" do
    login_as :quentin
    node = create_node_with_published_page
    node.find_or_create_draft User.first
    
    assert node.locked?
    
    put :unlock, params: { :id => node.id }
    assert_response :redirect
    assert !node.reload.locked?
  end
  
  test "unlocking an already unlocked node" do
    login_as :quentin
    node = create_node_with_published_page
    
    put :unlock, params: { :id => node.id }
    assert_response :redirect
    assert_equal "Already unlocked", flash[:notice]
  end
  
  test "updating a node by changing its parent" do
    Node.root.descendants.destroy_all
    login_as :quentin
    node = create_node_with_published_page
    node.find_or_create_draft User.first
    
    other_node = Node.root.children.create( :slug => "other" )
    
    node.staged_parent_id = other_node.id
    node.publish_draft!

    assert Node.valid?
  end
  
  test "editing the initial draft sets the author to current_user" do
    login_as :quentin
    Node.root.descendants.destroy_all
    node = create_node_with_draft
    get :edit, params: { :id => node.id }
    node.reload
    assert_equal "quentin", node.draft.user.login
  end
  
  test "updating the author of a node with existing head" do
    login_as :quentin
    Node.root.descendants.destroy_all
    node  = create_node_with_published_page
    assert_equal "quentin", node.head.user.login
    node.find_or_create_draft users(:quentin)
    assert node.draft.valid?
    assert node.valid?
    
    put :update, params: { :id => node.id, :page => {:user_id => users(:aaron).id} }
    assert_response :redirect
    assert_equal "aaron", node.reload.draft.user.login
  end
  
  test "updating an existing page should not modify published_at" do
    login_as :quentin
    Node.root.descendants.destroy_all
    node  = create_node_with_published_page
    
    get :edit, params: { :id => node.id }
    assert_response :success
    
    put :publish, params: { :id => node.id }
    
    node.reload
    assert_equal node.pages[0].published_at, node.pages[1].published_at
  end
  
  test "updating an exisiting page should not alter the author" do
    login_as :aaron
    Node.root.descendants.destroy_all
    node  = create_node_with_published_page
    get :edit,    params: { :id => node.id }
    
    put :publish, params: { :id => node.id }
    
    node.reload
    assert_equal node.pages[0].user, node.pages[1].user
  end
  
  test "editor and author are the same on a new node" do
    login_as :quentin
    node = create_node_with_draft
    get :edit, params: { :id => node.id }
    
    node.reload
    assert_equal "quentin", node.draft.user.login
    assert_equal "quentin", node.draft.editor.login
  end
  
  test "creating new draft alters the editor but keeps the author" do
    node = create_node_with_published_page
    assert_equal "quentin", node.head.user.login
    
    login_as :aaron
    get :edit,  params: {:id => node.id }
    
    node.reload
    assert_equal "quentin", node.head.user.login
    assert_equal "aaron",   node.draft.editor.login
  end
  
  test "unlocking and relocking changes editor if done by another user" do
    node  = create_node_with_published_page
    draft = node.find_or_create_draft users(:quentin)
    assert_equal draft.user.login, draft.editor.login
    assert node.locked?
    node.unlock!
    
    login_as :aaron
    get :edit, params: { :id => node.id }
    
    node.reload
    assert_equal "quentin", node.draft.user.login
    assert_equal "aaron", node.draft.editor.login
  end

  test "destroy a published node" do
    node = create_node_with_published_page
    node.destroy

    login_as :quentin
    get :index
  end

  test "no dangling pages remain after node removal" do
    node = create_node_with_published_page
    page_id = node.pages.first.id
    node.destroy

    assert_raises(ActiveRecord::RecordNotFound) do
      assert Page.find page_id
    end
  end

  test "can remove a node with an event" do
    node = create_node_with_published_page
    Event.create!(
      :start_time   => "2009-01-01T15:23:42".to_time,
      :end_time     => "2009-01-01T20:05:23".to_time,
      :url          => "http://events.ccc.de/congress/2082",
      :latitude     => 52.525308,
      :longitude    => 13.378944,
      :allday       => true,
      :node_id      => node.id
    )
    node.destroy

    login_as :quentin
    get :index
  end

end