surveyor_gui 0.0.3

data/lib/surveyor_gui/version.rb

@@ -0,0 +1,3 @@
+module SurveyorGui
+  VERSION = "0.0.3"
+end

data/lib/tasks/surveyor_gui_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :surveyor_gui do
+#   # Task goes here
+# end

data/lib/templates/erb/scaffold/_form.html.erb

@@ -0,0 +1,13 @@
+<%%= simple_form_for(@<%= singular_name %>) do |f| %>
+  <%%= f.error_notification %>
+
+  <div class="inputs">
+  <%- attributes.each do |attribute| -%>
+    <%%= f.<%= attribute.reference? ? :association : :input %> :<%= attribute.name %> %>
+  <%- end -%>
+  </div>
+
+  <div class="actions">
+    <%%= f.button :submit %>
+  </div>
+<%% end %>

data/spec/controllers/surveyforms_controller_spec.rb

@@ -0,0 +1,361 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe SurveyformsController do
+  include Surveyor::Engine.routes.url_helpers
+#  before do
+#    @routes = Surveyor::Engine.routes
+#  end
+
+  let!(:survey) { FactoryGirl.create(:survey, :title => "Alphabet", :access_code => "alpha", :survey_version => 0)}
+  let!(:survey_beta) { FactoryGirl.create(:survey, :title => "Alphabet", :access_code => "alpha", :survey_version => 1)}
+  let!(:survey_with_no_responses) {FactoryGirl.create(:survey)}
+  let!(:survey_with_responses) {FactoryGirl.create(:survey)}
+  let!(:template) {FactoryGirl.create(:template)}
+  let!(:surveyform) {FactoryGirl.create(:surveyform)}
+  let!(:response_set) { FactoryGirl.create(:survey_sections, :survey => survey_with_responses)}
+  let!(:response_set) { FactoryGirl.create(:response_set, :survey => survey_with_responses, :access_code => "pdq")}
+
+  def survey_with_sections
+    {
+      :title=>'New Survey',
+      :survey_sections_attributes => {
+        "0" => {
+          :title => 'New Section',
+          :display_order => 0
+        }
+      }
+    }
+  end
+
+  context "#index" do
+ 		def do_get(params = {})
+      get :index, params
+    end
+
+    context "index parameters specify surveys" do
+
+      it "set the title to 'manage surveys'" do
+        do_get()
+        assigns(:title).should eq("Manage Surveys")
+      end
+
+      it "should not populate an array of templates" do
+        do_get()
+        expect(assigns(:surveyforms)).not_to eq([template])
+      end
+
+      it "should populate an array of surveys" do
+        do_get()
+        expect(assigns(:surveyforms)).to include(surveyform)
+      end
+
+      it "shows the surveys" do
+        do_get()
+        expect(response).to render_template('index')
+      end
+    end
+
+    context "index parameters specify survey templates" do
+
+      it "set the title to 'manage templates'" do
+        do_get(:template=>"true")
+        assigns(:title).should eq("Manage Templates")
+      end
+
+      it "should populate an array of templates" do
+        do_get(params={:template=>"true"})
+        expect(assigns(:surveyforms)).to eq([template])
+      end
+
+      it "should not populate an array of surveys" do
+        do_get(params={:template=>"true"})
+        expect(assigns(:surveyforms)).not_to eq([surveyform])
+      end
+
+      it "shows the survey templates" do
+        do_get(:template=>"true")
+        expect(response).to render_template('index')
+      end
+    end
+  end
+
+  context "#new" do
+    def do_get
+      get :new
+    end
+
+    it "renders new" do
+      do_get
+      expect(response).to be_success
+      expect(response).to render_template('new')
+    end
+
+    it "populates an empty survey" do
+      do_get
+      expect(assigns(:surveyform).id).to eq(nil)
+    end
+  end
+
+  context "#create" do
+
+    def do_post(params = {})
+      post :create, :surveyform=>params
+    end
+
+    context "it saves successfully" do
+
+      it "returns to the edit page" do
+        do_post(:title=>'New surv')
+        expect(response).to redirect_to(edit_surveyform_url(assigns(:surveyform).id))
+      end
+
+      it "resets question_no to 0" do
+        do_post(:title=>'New surv')
+        expect(assigns(:question_no)).to eq(0)
+      end
+
+    end
+
+    context "it fails to save" do
+
+      it "renders new" do
+        do_post()
+        expect(response).to render_template('new')
+      end
+    end
+
+    context "if it includes survey sections" do
+
+        before :each do
+          @survey_with_sections = survey_with_sections
+        end
+
+      context "when sections are valid" do
+        it "redirects to the edit page" do
+          do_post @survey_with_sections
+          expect(response).to redirect_to(edit_surveyform_url(assigns(:surveyform).id))
+        end
+      end
+
+      context "when sections are not valid" do
+        before :each do
+          @survey_with_sections[:survey_sections_attributes]["0"][:display_order]=nil
+        end
+        it "renders new" do
+          do_post()
+          expect(response).to render_template('new')
+        end
+      end
+    end
+  end
+
+  context "#edit" do
+
+    context "the survey has no responses" do
+
+      def do_get(params = {})
+        get :edit, {:id => survey_with_no_responses.id}.merge(params)
+      end
+
+      it "renders edit" do
+        do_get
+        expect(response).to be_success
+        expect(response).to render_template('edit')
+      end
+    end
+
+    context "the survey has responses" do
+
+      def do_get(params = {})
+        get :edit, {:id => survey_with_responses.id}.merge(params)
+      end
+
+      it "still lets you see the edit page" do
+        do_get
+        expect(response).to be_success
+        expect(response).to render_template('edit')
+      end
+      it "warns that responses have been collected" do
+        expect(flash[:error]) =~ /been collected/i
+      end
+    end
+  end
+
+  context "#update" do
+
+    context "it saves successfully" do
+
+      def do_put(params = {})
+        put :update, params
+      end
+
+      it "redirects to index" do
+        do_put(:id=>survey.id,:surveyform=>{:id=>survey.id})
+        expect(response).to redirect_to(surveyforms_url)
+      end
+
+    end
+
+    context "it fails to save" do
+
+      def do_put(params = {})
+        put :update, params
+      end
+
+      it "renders edit" do
+        do_put(:id=>survey.id, :surveyform=>{:id=>survey.id,:title=>''})
+        expect(response).to render_template('edit')
+      end
+
+      it "resets question_no to 0" do
+        do_put(:id=>survey.id,:surveyform=>{:id=>survey.id,:title=>''})
+        expect(assigns(:question_no)).to eq(0)
+      end
+
+    end
+
+  end
+
+
+  context "#show" do
+    def do_get
+      get :show, {:id => survey.id}
+    end
+
+    it "shows survey" do
+      do_get
+      expect(response).to be_success
+      expect(response).to render_template('show')
+    end
+  end
+
+  context "#destroy" do
+
+    context "no responses were submitted" do
+      def do_delete
+        delete :destroy, :id => survey_with_no_responses
+      end
+
+      it "successfully destroys the survey" do
+        do_delete
+        expect(response).to redirect_to(surveyforms_url)
+        expect(Survey.exists?(survey_with_no_responses.id)).to be_false
+      end
+    end
+
+    context "responses were submitted" do
+      def do_delete
+        delete :destroy, :id => survey_with_responses
+      end
+
+      it "fails to delete the survey" do
+        do_delete
+        expect(response).to redirect_to(surveyforms_url)
+        expect(Survey.exists?(survey_with_responses.id)).to be_true
+      end
+
+      it "displays a flash message warning responses were collected" do
+        do_delete
+        expect(flash[:error]).to have_content /not be deleted/i
+      end
+    end
+  end
+
+  context "#replace form" do
+
+    def do_get(params = {})
+      FactoryGirl.create(:survey_section, :survey => survey)
+      get :replace_form, {:id=>survey.id,:survey_section_id=>survey.sections.first.id}.merge(params)
+    end
+
+    it "resets question_no to 0" do
+      do_get
+      expect(assigns(:question_no)).to eq(0)
+    end
+
+    it "renders new" do
+      do_get
+      expect(response).to be_success
+      expect(response).to render_template('new')
+    end
+
+  end
+
+  context "#insert_survey_section" do
+    def do_get(params = {})
+      survey.sections = [FactoryGirl.create(:survey_section, :survey => survey)]
+      get :insert_survey_section,{id: survey.id}.merge(params)
+    end
+    it "inserts a survey section" do
+      do_get
+      expect(response).to be_success
+      expect(response).to render_template('_survey_section_fields')
+    end
+  end
+
+  context "#replace_survey_section" do
+
+    def do_get(params = {})
+      FactoryGirl.create(:survey_section, :survey => survey)
+      get :replace_survey_section, {:id=>survey.id,:survey_section_id=>survey.sections.first.id}.merge(params)
+    end
+
+    it "resets question_no to 0" do
+      do_get
+      expect(assigns(:question_no)).to eq(0)
+    end
+
+    it "renders survey_section partial" do
+      do_get
+      expect(response).to be_success
+      expect(response).to render_template('_survey_section_fields')
+    end
+
+  end
+  context "#insert_new_question" do
+    def do_get(params = {})
+      survey.sections = [FactoryGirl.create(:survey_section, :survey => survey)]
+      survey.sections.first.questions = [FactoryGirl.create(:question, :survey_section => survey.sections.first)]
+      get :insert_new_question,{:id => survey.id, :question_id => survey.sections.first.questions.first.id}.merge(params)
+    end
+    it "inserts a question" do
+      do_get
+      expect(response).to be_success
+      expect(response).to render_template('new')
+    end
+  end
+
+  context "#cut_question" do
+    def do_get(params = {})
+      survey.sections = [FactoryGirl.create(:survey_section, :survey => survey)]
+      survey.sections.first.questions = [FactoryGirl.create(:question, :survey_section => survey.sections.first)]
+      get :cut_question,{:id => survey.id, :question_id => survey.sections.first.questions.first.id}.merge(params)
+    end
+    it "cuts a question" do
+      do_get
+      expect(response).to be_success
+    end
+  end
+
+  context "#clone_survey" do
+    def do_put(params={})
+      survey.sections = [FactoryGirl.create(:survey_section, :survey => survey)]
+      survey.sections.first.questions = [FactoryGirl.create(:question, :survey_section => survey.sections.first, text: 'my cloned question')]
+      put :clone_survey,{id: survey.id}
+    end
+
+    it "creates a new survey" do
+      expect{do_put}.to change{Survey.count}.by(1)
+    end
+
+    it "gives a different id to the clone" do
+      do_put
+      expect(Survey.last.id).not_to eql survey.id
+    end
+
+    it "copies the text of the question" do
+      do_put
+      expect(Survey.last.survey_sections.first.questions.first.text).to eql 'my cloned question'
+    end
+  end
+end

data/spec/controllers/surveyor_controller_spec.rb

@@ -0,0 +1,303 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe SurveyorController do
+  include Surveyor::Engine.routes.url_helpers
+  before do
+    @routes = Surveyor::Engine.routes
+  end
+
+  let!(:survey)           { FactoryGirl.create(:survey, :title => "Alphabet", :access_code => "alpha", :survey_version => 0)}
+  let!(:survey_beta)      { FactoryGirl.create(:survey, :title => "Alphabet", :access_code => "alpha", :survey_version => 1)}
+  let!(:response_set)      { FactoryGirl.create(:response_set, :survey => survey, :access_code => "pdq")}
+
+  before { ResponseSet.stub(:create).and_return(response_set) }
+
+  # match '/', :to                                     => 'surveyor#new', :as    => 'available_surveys', :via => :get
+  # match '/:survey_code', :to                         => 'surveyor#create', :as => 'take_survey', :via       => :post
+  # match '/:survey_code', :to                         => 'surveyor#export', :as => 'export_survey', :via     => :get
+  # match '/:survey_code/:response_set_code', :to      => 'surveyor#show', :as   => 'view_my_survey', :via    => :get
+  # match '/:survey_code/:response_set_code/take', :to => 'surveyor#edit', :as   => 'edit_my_survey', :via    => :get
+  # match '/:survey_code/:response_set_code', :to      => 'surveyor#update', :as => 'update_my_survey', :via  => :put
+
+  context "#new" do
+    def do_get
+      get :new
+    end
+    it "renders new" do
+      do_get
+      response.should be_success
+      response.should render_template('new')
+    end
+    it "assigns surveys_by_access_code" do
+      do_get
+      assigns(:surveys_by_access_code).should == {"alpha" => [survey_beta,survey]}
+    end
+  end
+
+  context "#create" do
+    def do_post(params = {})
+      post :create, {:survey_code => "alpha"}.merge(params)
+    end
+    it "finds latest version" do
+      do_post
+      assigns(:survey).should == survey_beta
+    end
+    it "finds specified survey_version" do
+      do_post :survey_version => 0
+      assigns(:survey).should == survey
+    end
+    it "creates a new response_set" do
+      ResponseSet.should_receive(:create)
+      do_post
+    end
+    it "should redirects to the new response_set" do
+      do_post
+      response.should redirect_to( edit_my_survey_path(:survey_code => "alpha", :response_set_code  => "pdq"))
+    end
+
+    context "with failures" do
+      it "redirect to #new on failed ResponseSet#create" do
+        ResponseSet.should_receive(:create).and_return(false)
+        do_post
+        response.should redirect_to(available_surveys_path)
+      end
+      it "redirect to #new on failed Survey#find" do
+        do_post :survey_code => "missing"
+        response.should redirect_to(available_surveys_path)
+      end
+    end
+
+    context "with javascript check, assigned in session" do
+      it "enabled" do
+        do_post :surveyor_javascript_enabled => "true"
+        session[:surveyor_javascript].should_not be_nil
+        session[:surveyor_javascript].should == "enabled"
+      end
+      it "disabled" do
+        post :create, :survey_code => "xyz", :surveyor_javascript_enabled => "not_true"
+        session[:surveyor_javascript].should_not be_nil
+        session[:surveyor_javascript].should == "not_enabled"
+      end
+    end
+  end
+
+  context "#show" do
+    def do_get(params = {})
+      get :show, {:survey_code => "alpha", :response_set_code => "pdq"}.merge(params)
+    end
+    it "renders show" do
+      do_get
+      response.should be_success
+      response.should render_template('show')
+    end
+    it "redirects for missing response set" do
+      do_get :response_set_code => "DIFFERENT"
+      response.should redirect_to(available_surveys_path)
+    end
+    it "assigns earlier survey_version" do
+      response_set
+      do_get
+      assigns[:response_set].should == response_set
+      assigns[:survey].should == survey
+    end
+    it "assigns later survey_version" do
+      response_set_beta = FactoryGirl.create(:response_set, :survey => survey_beta, :access_code => "rst")
+      do_get :response_set_code => "rst"
+      assigns[:response_set].should == response_set_beta
+      assigns[:survey].should == survey_beta
+    end
+  end
+
+  context "#edit" do
+    context "responses have been collected" do
+      def do_get(params = {})
+        @survey = FactoryGirl.create(:survey, :title => "Alphabet Soup", :access_code => "alphasoup", :survey_version => 0)
+        @survey.sections = [FactoryGirl.create(:survey_section, :survey => @survey)]
+        @response_set = FactoryGirl.create(:response_set, :survey => @survey, :access_code => "foo")
+        get :edit, {:survey_code => "alphasoup", :response_set_code => "foo"}.merge(params)
+      end
+      it "renders edit" do
+        do_get
+        response.should be_success
+        response.should render_template('edit')
+      end
+      it "assigns survey and response set" do
+        do_get
+        assigns[:survey].should == @survey
+        assigns[:response_set].should == @response_set
+      end
+      it "redirects for missing response set" do
+        do_get :response_set_code => "DIFFERENT"
+        response.should redirect_to(available_surveys_path)
+      end
+      it "assigns dependents if javascript not enabled" do
+        controller.stub(:get_unanswered_dependencies_minus_section_questions).and_return([FactoryGirl.create(:question)])
+        session[:surveyor_javascript].should be_nil
+        do_get
+        assigns[:dependents].should_not be_empty
+      end
+      it "does not assign dependents if javascript is enabled" do
+        controller.stub(:get_unanswered_dependencies_minus_section_questions).and_return([FactoryGirl.create(:question)])
+        session[:surveyor_javascript] = "enabled"
+        do_get
+        assigns[:dependents].should be_empty
+      end
+      it "assigns earlier survey_version" do
+        do_get
+        assigns[:response_set].should == @response_set
+        assigns[:survey].should == @survey
+      end
+      it "assigns later survey_version" do
+        survey_beta.sections = [FactoryGirl.create(:survey_section, :survey => survey_beta)]
+        response_set_beta = FactoryGirl.create(:response_set, :survey => survey_beta, :access_code => "rst")
+        do_get :response_set_code => "rst"
+        assigns[:survey].should == survey_beta
+        assigns[:response_set].should == response_set_beta
+      end
+    end
+  end
+
+  context "#update" do
+    let(:responses_ui_hash) { {} }
+    let(:update_params) {
+      {
+        :survey_code => "alpha",
+        :response_set_code => "pdq"
+      }
+    }
+    shared_examples "#update action" do
+      before do
+        ResponseSet.stub_chain(:includes, :where, :first).and_return(response_set)
+        responses_ui_hash['11'] = {'api_id' => 'something', 'answer_id' => '56', 'question_id' => '9'}
+      end
+      it "saves responses" do
+        response_set.should_receive(:update_from_ui_hash).with(responses_ui_hash)
+
+        do_put(:r => responses_ui_hash)
+      end
+      it "does not fail when there are no responses" do
+        lambda { do_put }.should_not raise_error
+      end
+      context "with update exceptions" do
+        it 'retries the update on a constraint violation' do
+          response_set.should_receive(:update_from_ui_hash).ordered.with(responses_ui_hash).and_raise(ActiveRecord::StatementInvalid.new(''))
+          response_set.should_receive(:update_from_ui_hash).ordered.with(responses_ui_hash)
+
+          expect { do_put(:r => responses_ui_hash) }.to_not raise_error
+        end
+
+        it 'only retries three times' do
+          response_set.should_receive(:update_from_ui_hash).exactly(3).times.with(responses_ui_hash).and_raise(ActiveRecord::StatementInvalid.new(''))
+
+          expect { do_put(:r => responses_ui_hash) }.to raise_error(ActiveRecord::StatementInvalid)
+        end
+
+        it 'does not retry for other errors' do
+          response_set.should_receive(:update_from_ui_hash).once.with(responses_ui_hash).and_raise('Bad news')
+
+          expect { do_put(:r => responses_ui_hash) }.to raise_error('Bad news')
+        end
+      end
+    end
+
+    context "with form submission" do
+      def do_put(extra_params = {})
+        put :update, update_params.merge(extra_params)
+      end
+
+      it_behaves_like "#update action"
+      it "redirects to #edit without params" do
+        do_put
+        response.should redirect_to(edit_my_survey_path(:survey_code => "alpha", :response_set_code => "pdq"))
+      end
+      it "completes the found response set on finish" do
+        do_put :finish => 'finish'
+        response_set.reload.should be_complete
+      end
+      it 'flashes completion' do
+        do_put :finish => 'finish'
+        flash[:notice].should == "Completed survey"
+      end
+      it "redirects for missing response set" do
+        do_put :response_set_code => "DIFFERENT"
+        response.should redirect_to(available_surveys_path)
+        flash[:notice].should == "Unable to find your responses to the survey"
+      end
+    end
+
+    context 'with ajax' do
+      def do_put(extra_params = {})
+        xhr :put, :update, update_params.merge(extra_params)
+      end
+
+      it_behaves_like "#update action"
+      it "returns dependencies" do
+        ResponseSet.stub_chain(:includes, :where, :first).and_return(response_set)
+        response_set.should_receive(:all_dependencies).and_return({"show" => ['q_1'], "hide" => ['q_2']})
+
+        do_put
+        JSON.parse(response.body).should == {"show" => ['q_1'], "hide" => ["q_2"]}
+      end
+      it "returns 404 for missing response set" do
+        do_put :response_set_code => "DIFFERENT"
+        response.status.should == 404
+      end
+    end
+  end
+
+  context "#export" do
+    render_views
+
+    let(:json) {
+      get :export, :survey_code => survey.access_code, :format => 'json'
+      JSON.parse(response.body)
+    }
+
+    context "question inside and outside a question group" do
+      def question_text(refid)
+        <<-SURVEY
+          q "Where is a foo?", :pick => :one, :help_text => 'Look around.', :reference_identifier => #{refid.inspect},
+            :data_export_identifier => 'X.FOO', :common_namespace => 'F', :common_identifier => 'f'
+          a_L 'To the left', :data_export_identifier => 'X.L', :common_namespace => 'F', :common_identifier => 'l'
+          a_R 'To the right', :data_export_identifier => 'X.R', :common_namespace => 'F', :common_identifier => 'r'
+          a_O 'Elsewhere', :string
+
+          dependency :rule => 'R'
+          condition_R :q_bar, "==", :a_1
+        SURVEY
+      end
+      let(:survey_text) {
+        <<-SURVEY
+          survey 'xyz' do
+            section 'Sole' do
+              q_bar "Should that other question show up?", :pick => :one
+              a_1 'Yes'
+              a_2 'No'
+
+              #{question_text('foo_solo')}
+
+              group do
+                #{question_text('foo_grouped')}
+              end
+            end
+          end
+        SURVEY
+      }
+      let(:survey) { Surveyor::Parser.new.parse(survey_text) }
+      let(:solo_question_json)    { json['sections'][0]['questions_and_groups'][1] }
+      let(:grouped_question_json) { json['sections'][0]['questions_and_groups'][2]['questions'][0] }
+
+      it "produces identical JSON except for API IDs and question reference identifers" do
+        solo_question_json['answers'].to_json.should be_json_eql( grouped_question_json['answers'].to_json).excluding("uuid", "reference_identifier")
+        solo_question_json['dependency'].to_json.should be_json_eql( grouped_question_json['dependency'].to_json).excluding("uuid", "reference_identifier")
+        solo_question_json.to_json.should be_json_eql( grouped_question_json.to_json).excluding("uuid", "reference_identifier")
+      end
+      it "produces the expected reference identifier for the solo question" do
+        solo_question_json['reference_identifier'].should == 'foo_solo'
+      end
+      it "produces the expected reference identifer for the question in the group" do
+        grouped_question_json['reference_identifier'].should == 'foo_grouped'
+      end
+    end
+  end
+end