require 'spec_helper'
require 'rails_helper'

# This spec was generated by rspec-rails when you ran the scaffold generator.
# It demonstrates how one might use RSpec to specify the controller code that
# was generated by Rails when you ran the scaffold generator.
#
# It assumes that the implementation code is generated by the rails scaffold
# generator.  If you are using any extension libraries to generate different
# controller code, this generated spec may or may not pass.
#
# It only uses APIs available in rails and/or rspec-rails.  There are a number
# of tools you can use to make these specs even more expressive, but we're
# sticking to rails and rspec-rails APIs to keep things simple and stable.
#
# Compared to earlier versions of this generator, there is very limited use of
# stubs and message expectations in this spec.  Stubs are only used when there
# is no simpler way to get a handle on the object needed for the example.
# Message expectations are only used when there is no simpler way to specify
# that an instance is receiving a specific message.

describe StrategiesController do
  describe "strategies.index" do
    let(:user) {FactoryGirl.create(:user)}
    let!(:st1) {FactoryGirl.create(:strategy, user: user, name: "st1", draw_type: INDIVIDUAL, sigma: nil)}
    let!(:st2) {FactoryGirl.create(:strategy, user: user, name: "st2", interest: 0.1, draw_type: INDIVIDUAL, sigma: nil)}
    before {visit strategies_path(user_id: user.id)}                               
#    before {visit strategies_path}                               
    describe "strategies", type: :temp do
      it {response.should be_success}
      it {expect(response).to eq(200)}
      it {expect(response).to be_success}
      it {expect(response).to render_template('strategies/index')}  
      #    it {expect(response).to redirect_to root_url}
      #    it {expect(response).to redirect_to strategies_path(user_id: user.id)}
      it {expect(assigns[:user]).to eq(nil)}
      it {expect(response).to have_text(user.id)}
      it {expect(response).to have_text(user.screen_name)}
      it {expect(response).to have_text(st1.name)}
      it {should have_content(user.screen_name)}
      it {expect(assigns[:strategies]).not_to eq(nil)}
      it {expect(assigns[:user]).not_to eq(nil)}
      it {expect(assigns[:user]).not_to be_nil}
      it {expect(assigns[:user].screen_name).to eq(user.screen_name)}
    end
    
    describe "strategies" do
      it {should have_content(st1.name)}
      it {should have_content(st1.positions.count)}
      it {should have_content(st2.name)}
      it {should have_content(st2.positions.count)}
    end
  end



  # # This should return the minimal set of attributes required to create a valid
  # # Strategy. As you add validations to Strategy, be sure to
  # # adjust the attributes here as well.
  # let(:valid_attributes) { { "name" => "MyString" } }

  # # This should return the minimal set of values that should be in the session
  # # in order to pass any filters (e.g. authentication) defined in
  # # StrategiesController. Be sure to keep this updated too.
  # let(:valid_session) { {} }

  # describe "GET index" do
  #   it "assigns all strategies as @strategies" do
  #     strategy = Strategy.create! valid_attributes
  #     get :index, {}, valid_session
  #     assigns(:strategies).should eq([strategy])
  #   end
  # end

  # describe "GET show" do
  #   it "assigns the requested strategy as @strategy" do
  #     strategy = Strategy.create! valid_attributes
  #     get :show, {:id => strategy.to_param}, valid_session
  #     assigns(:strategy).should eq(strategy)
  #   end
  # end

  # describe "GET new" do
  #   it "assigns a new strategy as @strategy" do
  #     get :new, {}, valid_session
  #     assigns(:strategy).should be_a_new(Strategy)
  #   end
  # end

  # describe "GET edit" do
  #   it "assigns the requested strategy as @strategy" do
  #     strategy = Strategy.create! valid_attributes
  #     get :edit, {:id => strategy.to_param}, valid_session
  #     assigns(:strategy).should eq(strategy)
  #   end
  # end

  # describe "POST create" do
  #   describe "with valid params" do
  #     it "creates a new Strategy" do
  #       expect {
  #         post :create, {:strategy => valid_attributes}, valid_session
  #       }.to change(Strategy, :count).by(1)
  #     end

  #     it "assigns a newly created strategy as @strategy" do
  #       post :create, {:strategy => valid_attributes}, valid_session
  #       assigns(:strategy).should be_a(Strategy)
  #       assigns(:strategy).should be_persisted
  #     end

  #     it "redirects to the created strategy" do
  #       post :create, {:strategy => valid_attributes}, valid_session
  #       response.should redirect_to(Strategy.last)
  #     end
  #   end

  #   describe "with invalid params" do
  #     it "assigns a newly created but unsaved strategy as @strategy" do
  #       # Trigger the behavior that occurs when invalid params are submitted
  #       Strategy.any_instance.stub(:save).and_return(false)
  #       post :create, {:strategy => { "name" => "invalid value" }}, valid_session
  #       assigns(:strategy).should be_a_new(Strategy)
  #     end

  #     it "re-renders the 'new' template" do
  #       # Trigger the behavior that occurs when invalid params are submitted
  #       Strategy.any_instance.stub(:save).and_return(false)
  #       post :create, {:strategy => { "name" => "invalid value" }}, valid_session
  #       response.should render_template("new")
  #     end
  #   end
  # end

  # describe "PUT update" do
  #   describe "with valid params" do
  #     it "updates the requested strategy" do
  #       strategy = Strategy.create! valid_attributes
  #       # Assuming there are no other strategies in the database, this
  #       # specifies that the Strategy created on the previous line
  #       # receives the :update_attributes message with whatever params are
  #       # submitted in the request.
  #       Strategy.any_instance.should_receive(:update).with({ "name" => "MyString" })
  #       put :update, {:id => strategy.to_param, :strategy => { "name" => "MyString" }}, valid_session
  #     end

  #     it "assigns the requested strategy as @strategy" do
  #       strategy = Strategy.create! valid_attributes
  #       put :update, {:id => strategy.to_param, :strategy => valid_attributes}, valid_session
  #       assigns(:strategy).should eq(strategy)
  #     end

  #     it "redirects to the strategy" do
  #       strategy = Strategy.create! valid_attributes
  #       put :update, {:id => strategy.to_param, :strategy => valid_attributes}, valid_session
  #       response.should redirect_to(strategy)
  #     end
  #   end

  #   describe "with invalid params" do
  #     it "assigns the strategy as @strategy" do
  #       strategy = Strategy.create! valid_attributes
  #       # Trigger the behavior that occurs when invalid params are submitted
  #       Strategy.any_instance.stub(:save).and_return(false)
  #       put :update, {:id => strategy.to_param, :strategy => { "name" => "invalid value" }}, valid_session
  #       assigns(:strategy).should eq(strategy)
  #     end

  #     it "re-renders the 'edit' template" do
  #       strategy = Strategy.create! valid_attributes
  #       # Trigger the behavior that occurs when invalid params are submitted
  #       Strategy.any_instance.stub(:save).and_return(false)
  #       put :update, {:id => strategy.to_param, :strategy => { "name" => "invalid value" }}, valid_session
  #       response.should render_template("edit")
  #     end
  #   end
  # end

  # describe "DELETE destroy" do
  #   it "destroys the requested strategy" do
  #     strategy = Strategy.create! valid_attributes
  #     expect {
  #       delete :destroy, {:id => strategy.to_param}, valid_session
  #     }.to change(Strategy, :count).by(-1)
  #   end

  #   it "redirects to the strategies list" do
  #     strategy = Strategy.create! valid_attributes
  #     delete :destroy, {:id => strategy.to_param}, valid_session
  #     response.should redirect_to(strategies_url)
  #   end
  # end

end
