helena 0.3.3

data/spec/features/helena/manage_session_spec.rb

@@ -0,0 +1,284 @@
+require 'spec_helper'
+
+feature 'Session management' do
+  let(:survey) { create :survey, name: 'dummy' }
+  let(:base_version) { survey.versions.create version: 0 }
+  let(:first_question_group) { build(:question_group, title: 'Page 1', position: 1) }
+
+  background do
+    base_version.survey_detail = build :survey_detail, title: 'Dummy Survey', description: 'Leucadendron is a plants in the family Proteaceae.'
+    base_version.question_groups << first_question_group
+  end
+
+  scenario 'edits a session' do
+    short_text_question  = build :short_text_question, code: 'a_name', question_text: "What's your name?"
+    first_question_group.questions << short_text_question
+
+    long_text_question  = build :long_text_question, code: 'selfdescription', question_text: 'Give a brief description of yourself'
+    first_question_group.questions << long_text_question
+
+    second_question_group = build(:question_group, title: 'Page 2', position: 2)
+    base_version.question_groups << second_question_group
+
+    all_and_everything = build :radio_group_question, code:           :all_and_everything,
+                                                      question_text:  'What is the answer to the Ultimate Question of Life, the Universe, and Everything?',
+                                                      position:       1
+
+    all_and_everything.labels << build(:label, position: 1, text: 'Just Chuck Norris knows it', value: 'norris')
+    all_and_everything.labels << build(:label, position: 2, text: 'God', value: 'god')
+    all_and_everything.labels << build(:label, position: 3, text: '42', value: 42)
+    all_and_everything.labels << build(:label, position: 4, text: 'Your mom', value: 'mom', preselected: :true)
+
+    second_question_group.questions << all_and_everything
+
+    food_allergy = build :checkbox_group_question, code:           :food_allergy,
+                                                   question_text:  'What kind of food allergy do you have?',
+                                                   position:       2
+
+    food_allergy.sub_questions << build(:sub_question, text: 'Garlic', code: 'garlic', position: 1, preselected: true)
+    food_allergy.sub_questions << build(:sub_question, text: 'Oats', code: 'oat', position: 2)
+    food_allergy.sub_questions << build(:sub_question, text: 'Meat', code: 'meat', position: 3)
+
+    second_question_group.questions << food_allergy
+
+    third_question_group = build(:question_group, title: 'Page 3', position: 3)
+
+    build :radio_group_question, code:           :all_and_everything,
+                                 question_text:  'What is the answer to the Ultimate Question of Life, the Universe, and Everything?',
+                                 position:       1
+
+    base_version.question_groups << third_question_group
+
+    satisfaction_matrix = build :radio_matrix_question, code:          :satisfaction,
+                                                        question_text: 'Below are five statements with which you may agree or disagree.',
+                                                        required:      true,
+                                                        position:      1
+
+    satisfaction_matrix.labels << build(:label, position: 1, text: 'Strongly Disagree', value: 1)
+    satisfaction_matrix.labels << build(:label, position: 2, text: 'Disagree', value: 2)
+    satisfaction_matrix.labels << build(:label, position: 3, text: 'Slightly Disagree', value: 3)
+    satisfaction_matrix.labels << build(:label, position: 4, text: 'Neither Agree or Disagree', value: 4)
+    satisfaction_matrix.labels << build(:label, position: 5, text: 'Slightly Agree', value: 5)
+    satisfaction_matrix.labels << build(:label, position: 6, text: 'Agree', value: 6)
+    satisfaction_matrix.labels << build(:label, position: 7, text: 'Strongly Agree', value: 7)
+
+    satisfaction_matrix.sub_questions << build(:sub_question, text: 'In most ways my life is close to my ideal.', code: 'life_is_ideal', position: 1)
+    satisfaction_matrix.sub_questions << build(:sub_question, text: 'The conditions of my life are excellent.', code: 'condition', position: 2)
+    satisfaction_matrix.sub_questions << build(:sub_question, text: 'I am satisfied with life.', code: 'satisfied_with_life', position: 3)
+    satisfaction_matrix.sub_questions << build(:sub_question, text:     'So far I have gotten the important things I want in life.',
+                                                              code:     'important_things',
+                                                              position: 4)
+    satisfaction_matrix.sub_questions << build(:sub_question, text: 'If I could live my life over, I would change almost nothing.',
+                                                              code: 'nothing_to_change',
+                                                              position: 5)
+
+    third_question_group.questions << satisfaction_matrix
+
+    version = Helena::VersionPublisher.publish(base_version)
+    version.save
+
+    session = survey.sessions.create version_id: version.id, token: 'abc'
+
+    visit helena.edit_session_path(session.token)
+
+    expect(page).to have_content 'Dummy Survey'
+    expect(page).to have_content 'Page 1'
+    expect(page).to have_content "What's your name?"
+    expect(page).to have_content 'Give a brief description of yourself'
+
+    expect(page).not_to have_link 'Back'
+
+    fill_in 'session_answers_a_name', with: 'Hans'
+    fill_in 'session_answers_selfdescription', with: 'I am a proud man living in middle earth. Everybody is laughing at me because I do not have hairy feets.'
+
+    expect { click_button 'Next' }.to change { session.reload.answers.count }.from(0).to(2)
+
+    expect(page).to have_content 'Page 2'
+
+    expect(page).to have_content 'What is the answer to the Ultimate Question of Life, the Universe, and Everything?'
+    expect(page).to have_content 'Just Chuck Norris knows it'
+    expect(page).to have_content 'God'
+    expect(page).to have_content '42'
+    expect(page).to have_content 'Your mom'
+
+    choose('42')
+
+    expect(page).to have_content 'What kind of food allergy do you have?'
+    expect(page).to have_content 'Garlic'
+    expect(page).to have_content 'Oats'
+    expect(page).to have_content 'Meat'
+
+    uncheck('Garlic')
+    check('Oats')
+    check('Meat')
+
+    expect(page).to have_link 'Back'
+    expect { click_button 'Next' }.to change { session.reload.answers.count }.from(2).to(6)
+
+    expect(page).to have_content 'Page 3'
+
+    expect(page).to have_content 'Below are five statements with which you may agree or disagree.'
+
+    expect(page).to have_content 'Strongly Disagree'
+    expect(page).to have_content 'Disagree'
+    expect(page).to have_content 'Slightly Disagree'
+    expect(page).to have_content 'Neither Agree or Disagree'
+    expect(page).to have_content 'Slightly Agree'
+    expect(page).to have_content 'Agree'
+    expect(page).to have_content 'Strongly Agree'
+
+    expect(page).to have_content 'In most ways my life is close to my ideal.'
+    expect(page).to have_content 'The conditions of my life are excellent.'
+    expect(page).to have_content 'I am satisfied with life.'
+    expect(page).to have_content 'So far I have gotten the important things I want in life.'
+    expect(page).to have_content 'If I could live my life over, I would change almost nothing.'
+
+    choose('session_answers_life_is_ideal_1')
+    choose('session_answers_important_things_2')
+    choose('session_answers_condition_4')
+    choose('session_answers_nothing_to_change_5')
+    choose('session_answers_satisfied_with_life_7')
+
+    expect { click_button 'Save' }.to change { session.reload.answers.count }.from(6).to(11)
+  end
+
+  scenario 'does not save an empty short text field when required' do
+    short_text_question  = build :short_text_question, code: 'a_name', question_text: "What's your name?", required: true
+    first_question_group.questions << short_text_question
+
+    version = Helena::VersionPublisher.publish(base_version)
+    version.save
+
+    session = survey.sessions.create version_id: version.id, token: 'abc'
+
+    visit helena.edit_session_path(session.token)
+
+    expect(page).to have_content "What's your name? *"
+    expect { click_button 'Save' }.not_to change { session.reload.answers.count }
+    expect(page).to have_content("can't be blank")
+  end
+
+  scenario 'does not save an empty long text field when required' do
+    long_text_question  = build :long_text_question, code: 'selfdescription', question_text: 'Give a brief description of yourself', required: true
+    first_question_group.questions << long_text_question
+
+    version = Helena::VersionPublisher.publish(base_version)
+    version.save
+
+    session = survey.sessions.create version_id: version.id, token: 'abc'
+
+    visit helena.edit_session_path(session.token)
+
+    expect(page).to have_content 'Give a brief description of yourself *'
+    expect { click_button 'Save' }.not_to change { session.reload.answers.count }
+    expect(page).to have_content("can't be blank")
+  end
+
+  scenario 'does not save a non selected radio group when required' do
+    all_and_everything = build :radio_group_question, code:           :all_and_everything,
+                                                      question_text:  'What is the answer to the Ultimate Question of Life, the Universe, and Everything?',
+                                                      required:       true
+
+    all_and_everything.labels << build(:label, value: 'norris')
+    all_and_everything.labels << build(:label, value: 'god')
+    all_and_everything.labels << build(:label, value: 42)
+    all_and_everything.labels << build(:label, value: 'mom')
+
+    first_question_group.questions << all_and_everything
+
+    version = Helena::VersionPublisher.publish(base_version)
+    version.save
+
+    session = survey.sessions.create version_id: version.id, token: 'abc'
+
+    visit helena.edit_session_path(session.token)
+
+    expect(page).to have_content 'What is the answer to the Ultimate Question of Life, the Universe, and Everything? *'
+    expect { click_button 'Save' }.not_to change { session.reload.answers.count }
+    expect(page).to have_content("can't be blank")
+  end
+
+  scenario 'does not save when no subquestion of a checkbox group is selected if required' do
+    food_allergy = build :checkbox_group_question, code:           :food_allergy,
+                                                   question_text:  'What kind of food allergy do you have?',
+                                                   required:       true
+
+    food_allergy.sub_questions << build(:sub_question, text: 'Garlic', code: 'garlic')
+    food_allergy.sub_questions << build(:sub_question, text: 'Oats', code: 'oat')
+    food_allergy.sub_questions << build(:sub_question, text: 'Meat', code: 'meat')
+
+    first_question_group.questions << food_allergy
+
+    version = Helena::VersionPublisher.publish(base_version)
+    version.save
+
+    session = survey.sessions.create version_id: version.id, token: 'abc'
+
+    visit helena.edit_session_path(session.token)
+
+    expect(page).to have_content 'What kind of food allergy do you have? *'
+    expect { click_button 'Save' }.to change { session.reload.answers.map(&:value) }.from([]).to([0, 0, 0])
+    expect(page).to have_content("can't be blank")
+  end
+
+  scenario 'saves when subquestion of a checkbox group is selected if required' do
+    food_allergy = build :checkbox_group_question, code:           :food_allergy,
+                                                   question_text:  'What kind of food allergy do you have?',
+                                                   required:       true
+
+    food_allergy.sub_questions << build(:sub_question, text: 'Garlic', code: 'garlic')
+    food_allergy.sub_questions << build(:sub_question, text: 'Oats', code: 'oat')
+    food_allergy.sub_questions << build(:sub_question, text: 'Meat', code: 'meat')
+
+    first_question_group.questions << food_allergy
+
+    version = Helena::VersionPublisher.publish(base_version)
+    version.save
+
+    session = survey.sessions.create version_id: version.id, token: 'abc'
+
+    visit helena.edit_session_path(session.token)
+
+    expect(page).to have_content 'What kind of food allergy do you have? *'
+    check('Oats')
+    expect { click_button 'Save' }.to change { session.reload.answers.count }.from(0).to(3)
+    expect(page).not_to have_content("can't be blank")
+  end
+
+  scenario 'does not save when radio matrix is filled out completely if required' do
+    satisfaction_matrix = build :radio_matrix_question, code:          :satisfaction,
+                                                        question_text: 'Below are five statements with which you may agree or disagree.',
+                                                        required:      true
+
+    satisfaction_matrix.labels << build(:label, value: 1)
+    satisfaction_matrix.labels << build(:label, value: 2)
+    satisfaction_matrix.labels << build(:label, value: 3)
+    satisfaction_matrix.labels << build(:label, value: 4)
+    satisfaction_matrix.labels << build(:label, value: 5)
+    satisfaction_matrix.labels << build(:label, value: 6)
+    satisfaction_matrix.labels << build(:label, value: 7)
+
+    satisfaction_matrix.sub_questions << build(:sub_question, code: 'life_is_ideal')
+    satisfaction_matrix.sub_questions << build(:sub_question, code: 'condition')
+    satisfaction_matrix.sub_questions << build(:sub_question, code: 'satisfied_with_life')
+    satisfaction_matrix.sub_questions << build(:sub_question, code: 'important_things')
+    satisfaction_matrix.sub_questions << build(:sub_question, code: 'nothing_to_change')
+
+    first_question_group.questions << satisfaction_matrix
+
+    version = Helena::VersionPublisher.publish(base_version)
+    version.save
+
+    session = survey.sessions.create version_id: version.id, token: 'abc'
+
+    visit helena.edit_session_path(session.token)
+
+    expect(page).to have_content 'Below are five statements with which you may agree or disagree. *'
+
+    choose('session_answers_satisfied_with_life_3')
+
+    expect { click_button 'Save' }.to change { session.reload.answers.count }.from(0).to(1)
+
+    expect(page).to have_content("can't be blank")
+  end
+end

data/spec/features/helena/manage_survey_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+feature 'Survey management' do
+  scenario 'lists all surveys' do
+    first_survey = create :survey, name: 'first'
+    first_survey.versions.create version: 0
+    first_survey.versions.first.survey_detail = Helena::SurveyDetail.new(title: 'My first survey', description: 'I am very proud of it')
+    second_survey = create :survey, name: 'second'
+    second_survey.versions.create version: 0
+    second_survey.versions.first.survey_detail = Helena::SurveyDetail.new(title: 'Another cool survey', description: 'Everybody likes it')
+
+    visit helena.surveys_path
+
+    within "#helena_#{dom_id first_survey}" do
+      expect(page).to have_text 'My first survey'
+      expect(page).to have_text 'I am very proud of it'
+    end
+
+    within "#helena_#{dom_id second_survey}" do
+      expect(page).to have_text 'Another cool survey'
+      expect(page).to have_text 'Everybody likes it'
+    end
+  end
+end

data/spec/lib/version_publisher_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Helena::VersionPublisher do
+  let!(:survey) { create :survey }
+  let!(:base_version) { survey.versions.create version: 42 }
+  let!(:survey_detail) { base_version.survey_detail = build :survey_detail }
+  let!(:question_group) { base_version.question_groups.create }
+  let!(:question) { build(:radio_matrix_question, code: 'abc', question_group: question_group) }
+  let!(:label) {  build(:label, text: 'xyz', value: 'asdf', question: question) }
+  let!(:sub_question) { build(:sub_question, text: 'ymca', code: 'cde', question: question) }
+
+  it 'creates a new version' do
+    allow(DateTime).to receive(:now).and_return('Tue, 24 Jun 2014 10:24:08 +0200')
+
+    new_version = Helena::VersionPublisher.publish(base_version)
+
+    expect(new_version.version).to eq 43
+    expect(new_version.survey_detail).to be_a Helena::SurveyDetail
+    expect(new_version).to have(1).question_groups
+    expect(new_version.question_groups.first).to have_exactly(1).questions
+    expect(new_version.question_groups.first.questions.first).to have_exactly(1).labels
+    expect(new_version.question_groups.first.questions.first).to have_exactly(1).sub_questions
+    expect(new_version.created_at).to eq 'Tue, 24 Jun 2014 10:24:08 +0200'
+    expect(new_version.updated_at).to eq 'Tue, 24 Jun 2014 10:24:08 +0200'
+  end
+end

data/spec/models/helena/answer_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe Helena::Answer do
+
+  let(:survey) { create :survey }
+  let(:version) { build :version, survey: survey }
+  let(:session) { create :session, survey: survey, version: version }
+
+  it { expect(subject).to be_embedded_in(:session) }
+
+  it { expect(subject).to validate_presence_of(:code) }
+  it { expect(subject).to validate_uniqueness_of(:code) }
+  it { expect(subject).to validate_presence_of(:ip_address) }
+
+  it 'saves the created_at time when create an answer' do
+    expect(build(:answer).created_at).to be_kind_of(DateTime)
+  end
+
+  it 'has a valid factory' do
+    expect(build :answer).to be_valid
+  end
+
+  describe '.build_generic' do
+    it 'builds an integer answer' do
+      expect(Helena::Answer.build_generic('bla', 42, '192.168.0.1')).to be_kind_of(Helena::IntegerAnswer)
+    end
+
+    it 'builds an integer answer from a string integer' do
+      expect(Helena::Answer.build_generic('bla', '42', '192.168.0.1')).to be_kind_of(Helena::IntegerAnswer)
+    end
+
+    it 'builds a string answer' do
+      expect(Helena::Answer.build_generic('bla', 'look at my horse, my horse is a amazing', '192.168.0.1')).to be_kind_of(Helena::StringAnswer)
+    end
+
+    it 'builds a boolean answer for string "true"' do
+      expect(Helena::Answer.build_generic('bla', 'true', '192.168.0.1')).to be_kind_of(Helena::BooleanAnswer)
+    end
+
+    it 'builds a boolean answer for string "false"' do
+      expect(Helena::Answer.build_generic('bla', 'false', '192.168.0.1')).to be_kind_of(Helena::BooleanAnswer)
+    end
+
+    it 'builds a boolean answer for true' do
+      expect(Helena::Answer.build_generic('bla', 'true', '192.168.0.1')).to be_kind_of(Helena::BooleanAnswer)
+    end
+
+    it 'builds a boolean answer for false' do
+      expect(Helena::Answer.build_generic('bla', 'false', '192.168.0.1')).to be_kind_of(Helena::BooleanAnswer)
+    end
+  end
+
+end

data/spec/models/helena/label_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Helena::Label do
+
+  it { expect(subject).to be_embedded_in(:question) }
+  it { expect(subject).to validate_presence_of(:text) }
+  it { expect(subject).to validate_presence_of(:value) }
+  it { expect(subject).to validate_uniqueness_of(:value) }
+
+  it 'has a valid factory' do
+    expect(build :label).to be_valid
+  end
+end

data/spec/models/helena/question_group_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Helena::QuestionGroup do
+  let!(:version) { create :version, survey: create(:survey) }
+
+  it { expect(subject).to be_embedded_in(:version) }
+
+  it 'has a valid factory' do
+    expect(build :question_group).to be_valid
+  end
+end

data/spec/models/helena/question_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Helena::Question do
+  let!(:version) { create :version, survey: create(:survey) }
+
+  it { expect(subject).to be_embedded_in(:question_group) }
+
+  it { expect(subject).to validate_presence_of(:code) }
+
+  it 'validates uniqness of code across different question_groups' do
+    a_question = build :question, question_group: build(:question_group, version: version), code: :preferred_color
+    expect(a_question).to be_valid
+
+    another_question = build :question, question_group: build(:question_group, version: version), code: :preferred_color
+    expect(another_question).not_to be_valid
+  end
+
+  it 'has a valid factory' do
+    expect(build :question, question_group: build(:question_group, version: version)).to be_valid
+  end
+end

data/spec/models/helena/questions/radio_group_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Helena::Questions::RadioGroup do
+  let!(:version) { build :version, survey: build(:survey) }
+
+  let(:question_group) { build :question_group, version: version }
+
+  it 'has a valid factory' do
+    expect(build :radio_group_question, question_group: question_group).to be_valid
+  end
+
+  it 'validates uniquness of label preselection' do
+    question = create :radio_group_question, question_group: question_group
+    question.labels << build(:label, preselected: true)
+    question.labels << build(:label, preselected: true)
+    expect(question).not_to be_valid
+  end
+
+  it 'does not validates uniquness of label preselection for no preselection' do
+    question = create :radio_group_question, question_group: question_group
+    question.labels << build(:label, preselected: false)
+    question.labels << build(:label, preselected: false)
+    expect(question).to be_valid
+  end
+
+  it 'does not validates uniquness of label preselection for one preselection' do
+    question = create :radio_group_question, question_group: question_group
+    question.labels << build(:label, preselected: false)
+    question.labels << build(:label, preselected: false)
+    expect(question).to be_valid
+  end
+end

data/spec/models/helena/questions/radio_matrix_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Helena::Questions::RadioMatrix do
+  let!(:version) { create :version, survey: create(:survey) }
+
+  let(:question_group) { build :question_group, version: version }
+
+  it 'has a valid factory' do
+    expect(build :radio_matrix_question, question_group: question_group).to be_valid
+  end
+
+  it 'validates uniquness of label preselection' do
+    question = create :radio_matrix_question, question_group: question_group
+    question.labels << build(:label, preselected: true)
+    question.labels << build(:label, preselected: true)
+    expect(question).not_to be_valid
+  end
+
+  it 'does not validates uniquness of label preselection for no preselection' do
+    question = create :radio_matrix_question, question_group: question_group
+    question.labels << build(:label, preselected: false)
+    question.labels << build(:label, preselected: false)
+    expect(question).to be_valid
+  end
+
+  it 'does not validates uniquness of label preselection for one preselection' do
+    question = create :radio_matrix_question, question_group: question_group
+    question.labels << build(:label, preselected: false)
+    question.labels << build(:label, preselected: false)
+    expect(question).to be_valid
+  end
+end

data/spec/models/helena/questions/short_text_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe Helena::Questions::ShortText do
+  let(:version) { build :version, version: 0 }
+  let(:question_group) { build(:question_group, version: version) }
+
+  it 'has a valid factory' do
+    expect(build :short_text_question, question_group: question_group).to be_valid
+  end
+end

data/spec/models/helena/session_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Helena::Session do
+  it { expect(subject).to belong_to(:survey) }
+  it { expect(subject).to belong_to(:version) }
+
+  it { expect(subject).to embed_many(:answers) }
+
+  it { expect(subject).to validate_uniqueness_of(:token) }
+  it { expect(subject).to validate_uniqueness_of(:view_token) }
+
+  it 'has a valid factory' do
+    expect(build :session).to be_valid
+  end
+
+  it 'assigns a token after when creating a session' do
+    expect_any_instance_of(Helena::Session).to receive(:generate_token).exactly(2).times.and_return('a493oP')
+    expect(create(:session_without_token).token).to eq 'a493oP'
+  end
+end

data/spec/models/helena/sub_question_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Helena::SubQuestion do
+  let(:version) { create :version, survey: create(:survey) }
+  let(:question_group) { build :question_group, version: version }
+  let(:question) { build :radio_matrix_question, question_group: question_group }
+
+  it { expect(subject).to be_embedded_in(:question) }
+  it { expect(subject).to validate_uniqueness_of(:text) }
+  it { expect(subject).to validate_presence_of(:text) }
+
+  it 'validates uniqness of code across different question_groups with subquestions' do
+    a_question = build :question, question_group: build(:question_group, version: version), code: :preferred_color
+    expect(a_question).to be_valid
+
+    another_question = build :question, question_group: build(:question_group, version: version), code: :colors
+
+    sub_question = build :sub_question, question: another_question, code: :some_code
+    expect(sub_question).to be_valid
+
+    another_sub_question = build :sub_question, question: another_question, code: :preferred_color
+    expect(another_sub_question).not_to be_valid
+  end
+
+  it 'has a valid factory' do
+    expect(build :sub_question, question: question).to be_valid
+  end
+end

data/spec/models/helena/survey_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Helena::Survey do
+  it { expect(subject).to embed_many(:versions) }
+  it { expect(subject).to have_many(:sessions).with_dependent(:destroy) }
+
+  it { expect(subject).to validate_presence_of(:name) }
+  it { expect(subject).to validate_presence_of(:language) }
+  it { expect(subject).to validate_uniqueness_of(:name) }
+
+  it 'has a valid factory' do
+    expect(build :survey).to be_valid
+  end
+end

data/spec/models/helena/version_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Helena::Version do
+  it { expect(subject).to be_embedded_in(:survey) }
+
+  it { expect(subject).to embed_many(:question_groups) }
+  it { expect(subject).to embed_one(:survey_detail) }
+
+  it { expect(subject).to validate_presence_of(:version) }
+  it { expect(subject).to validate_uniqueness_of(:version) }
+
+  it 'has a valid factory' do
+    expect(build :version, survey: create(:survey)).to be_valid
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,43 @@
+require 'ffaker'
+require 'coveralls'
+
+Coveralls.wear!
+
+# Configure Rails Envinronment
+ENV['RAILS_ENV'] = 'test'
+require File.expand_path('../dummy/config/environment.rb',  __FILE__)
+
+require 'rspec/rails'
+require 'factory_girl_rails'
+require 'database_cleaner'
+require 'mongoid-rspec'
+require 'capybara/rspec'
+require 'rspec/collection_matchers'
+
+ENGINE_RAILS_ROOT = File.join(File.dirname(__FILE__), '../')
+
+# Requires supporting ruby files with custom matchers and macros, etc,
+# in spec/support/ and its subdirectories.
+Dir[File.join(ENGINE_RAILS_ROOT, 'spec/support/**/*.rb')].each { |f| require f }
+
+RSpec.configure do |config|
+  config.order = :random
+  config.include ActionView::RecordIdentifier, type: :feature
+
+  config.include Mongoid::Matchers, type: :model
+
+  # We don't want write FactoryGirl all the time
+  config.include FactoryGirl::Syntax::Methods
+
+  config.infer_spec_type_from_file_location!
+
+  DatabaseCleaner.strategy = :truncation
+
+  config.before(:each) do
+    DatabaseCleaner.start
+  end
+
+  config.after(:each) do
+    DatabaseCleaner.clean
+  end
+end