qwester 0.0.1

data/test/unit/qwester/answer_test.rb

@@ -0,0 +1,47 @@
+require 'test_helper'
+
+module Qwester
+
+  class AnswerTest < ActiveSupport::TestCase
+    def setup
+      @answer = Answer.find(1)
+    end
+
+    def test_find_first_or_create
+      answer = Answer.find_first_or_create(
+        :value => @answer.value,
+        :question_id => @answer.question_id
+      )
+      assert_equal(@answer, answer)
+    end
+
+    def test_find_first_or_create_when_answer_does_not_exist
+      new_value = 'something'
+      assert_difference 'Answer.count' do
+        answer = Answer.find_first_or_create(
+          :value => 'something',       
+          :question_id => Question.first.id
+        )
+      end
+      assert_equal(new_value, Answer.last.value)
+    end
+
+    def test_destroy
+      rule_set = RuleSet.first
+      answer_store = AnswerStore.first
+      @answer.rule_sets = [rule_set]
+      @answer.answer_stores = [answer_store]
+      assert_difference 'Answer.count', -1 do
+        assert_difference 'rule_set.answers.count', -1 do
+          assert_difference 'answer_store.answers.count', -1 do
+            @answer.destroy
+          end
+        end
+      end
+    end
+
+    def test_rule_label
+      assert_equal("a#{@answer.id}", @answer.rule_label)
+    end
+  end
+end

data/test/unit/qwester/question_test.rb

@@ -0,0 +1,42 @@
+require_relative '../../test_helper'
+module Qwester
+
+  class QuestionTest < ActiveSupport::TestCase
+
+    def setup
+      @question = Question.find(2)
+    end
+
+    def test_setup
+      assert_equal(0, @question.answers.count)
+    end
+
+    def test_build_standard_answers
+      assert_no_difference 'Answer.count' do
+        @question.build_standard_answers
+        assert_question_has_standard_answers
+      end
+    end
+
+    def test_create_standard_answers
+      assert_difference 'Answer.count', Answer.standard_values.length do
+        @question.create_standard_answers
+        assert_question_has_standard_answers
+      end
+    end
+
+    def test_destroy
+      test_create_standard_answers
+      assert_difference 'Question.count', -1 do
+        assert_difference 'Answer.count', -(Answer.standard_values.length) do
+          @question.destroy
+        end
+      end
+    end
+
+    private
+    def assert_question_has_standard_answers
+      assert_equal(Answer.standard_values, @question.answers.collect(&:value))
+    end
+  end
+end

data/test/unit/qwester/questionnaire_test.rb

@@ -0,0 +1,18 @@
+require_relative '../../test_helper'
+module Qwester
+
+  class QuestionnaireTest < ActiveSupport::TestCase
+    def setup
+      @questionnaire = Questionnaire.find(1)
+    end
+
+    # Overriding this method, so want to make sure default behaviour still works
+    # Tests for methods over-riding this are in other test, e.g. questionnaires_question_test.rb
+    def test_method_missing
+      assert_raise NoMethodError do
+        @questionnaire.no_such_method
+      end
+    end
+  end
+  
+end

data/test/unit/qwester/questionnaires_question_test.rb

@@ -0,0 +1,62 @@
+require_relative '../../test_helper'
+module Qwester
+
+  class QuestionnairesQuestionTest < ActiveSupport::TestCase
+    def setup
+      @questionnaires_question = QuestionnairesQuestion.find(1)
+      @questionnaire = @questionnaires_question.questionnaire
+      @question = Question.find(2)
+    end
+
+    def test_setup
+      assert_not_equal(@questionnaires_question.question, @question)
+    end
+
+    def test_position
+      @questionnaire.questions << @question
+      assert_equal(1, @questionnaires_question.position)
+      assert_equal(2, QuestionnairesQuestion.last.position)
+    end
+
+    def test_move_question_up
+      test_position
+      @questionnaire.move_higher(@question)
+      assert_equal(2, @questionnaires_question.reload.position)
+      assert_equal(1, QuestionnairesQuestion.last.position)    
+    end
+
+    def test_second_questionnaire_not_affected_by_positioning_in_first
+      questionnaire = Questionnaire.find(2)
+      question = Question.find(1)
+      questionnaire.questions << question
+      questionnaire.questions << @question
+      assert_not_equal(@questionnaire, questionnaire, "should be working with two questionnaires")
+      assert_equal([question, @question], questionnaire.questions)
+      assert_equal([question], @questionnaire.questions)
+      test_move_question_up
+      assert_equal([question, @question], questionnaire.reload.questions)
+      assert_equal([@question, question], @questionnaire.reload.questions)
+    end
+
+    def test_adding_question_again_does_not_create_duplicates
+      @questionnaire.questions << @question
+      assert_no_difference '@questionnaire.questions.count' do
+        @questionnaire.reload.questions << @question
+      end
+    end
+
+    def test_removing_quesition
+      test_adding_question_again_does_not_create_duplicates
+      @questionnaire.questions.delete(@question)
+      assert_equal(1, @questionnaire.questions.count)
+    end
+
+    def test_removing_question_deletes_questionnaires_question_but_does_not_delete_question
+      assert_no_difference 'Question.count' do
+        assert_difference 'QuestionnairesQuestion.count', -1 do
+          @questionnaire.questions.delete(@questionnaire.questions.first)
+        end
+      end
+    end
+  end
+end

data/test/unit/qwester/rule_set_test.rb

@@ -0,0 +1,134 @@
+require_relative '../../test_helper'
+module Qwester
+
+  class RuleSetTest < ActiveSupport::TestCase
+    def setup
+      @rule_set = RuleSet.find(1)
+      @answer = Answer.find(1)
+      @other_answer = Answer.find(2)
+      @rule_set.answers << @answer
+    end
+
+    def test_match
+      assert(@rule_set.match(@rule_set.answers), "should match if rule_set.answers equal answers passed in")
+    end
+
+    def test_match_when_additional_answers_passed_in
+      assert(@rule_set.match([@rule_set.answers, @other_answer].flatten), "should match as long as answers passed in include ruleset.answers")
+    end
+
+    def test_match_failure
+      assert_no_rule_set_match([@other_answer])
+    end
+
+    def test_partial_match
+      @rule_set.answers << @other_answer
+      assert(@rule_set.match([@other_answer]), "should match as long as answers includes @other_answer")
+    end
+
+    def test_match_when_no_answers_passed_in
+      assert_no_rule_set_match([])
+    end
+
+    def test_match_when_nil_passed_in
+      assert_no_rule_set_match(nil)
+    end
+
+    def test_matches
+      create_more_rule_sets
+      rule_sets = RuleSet.matching([@answer])
+      assert_equal(2, rule_sets.length)
+      assert(rule_sets.include?(@rule_set), "RuleSet @rule_set should be included")
+      assert(rule_sets.include?(@rule_set_one), "RuleSet one should be included")
+      assert(!rule_sets.include?(@rule_set_two), "RuleSet two should not be included")
+    end
+
+    def test_matchs_with_where
+      create_more_rule_sets
+      rule_sets = RuleSet.where(:title => @rule_set.title).matching([@answer])
+      assert_equal([@rule_set], rule_sets)
+    end
+
+    def test_custom_rule
+      create_custom_rule_set('a1 and a2')
+      assert(@rule_set.match([@answer, @other_answer]), "Should match as both answers present")
+      assert(!@rule_set.match([@answer]), "Should not match as other answer missing") 
+    end
+
+    def test_custom_rule_or
+      create_custom_rule_set('a1 or a2')
+      assert(@rule_set.match([@answer, @other_answer]), "Should match as both answers present")
+      assert(@rule_set.match([@answer]), "Should match as answer present")  
+    end
+
+    def test_custom_rule_in
+      create_custom_rule_set('2 in a1 a2')
+      assert(@rule_set.match([@answer, @other_answer]), "Should match as both answers present")
+      assert(!@rule_set.match([@answer]), "Should not match as only one answer present")  
+    end
+
+    def test_matching_answer_sets
+      create_custom_rule_set('a1 and a2')
+      assert_equal([[1, 2]], @rule_set.matching_answer_sets)
+    end
+
+    def test_blocking_answer_sets
+      create_custom_rule_set('a1 and a2')
+      assert_equal([[1], [2]], @rule_set.blocking_answer_sets)
+    end
+
+    def test_default_rules_created_from_answers_on_create
+      rule_set = RuleSet.create(:title => 'One', :answers => [@answer], :url => 'http://undervale.co.uk')
+      assert_equal(rule_set.default_rule, rule_set.rule)
+      rule_set = RuleSet.create(:title => 'Two', :answers => [@answer, @other_answer], :url => 'http://undervale.co.uk')
+      assert_equal(rule_set.default_rule, rule_set.rule)
+    end
+
+    def test_default_rule
+      assert_equal(@answer.rule_label, @rule_set.default_rule)
+      @rule_set.answers << @other_answer
+      expected = "#{@answer.rule_label} #{RuleSet::DEFAULT_RULE_JOIN} #{@other_answer.rule_label}"
+      assert_equal(expected, @rule_set.default_rule)
+    end
+
+    def test_answers_populated_by_rules
+      test_custom_rule
+      assert_equal([@answer, @other_answer], @rule_set.answers)
+    end
+
+    def test_answers_shrink_when_answer_removed_from_rule
+      test_answers_populated_by_rules
+      @rule_set.rule = 'a1'
+      @rule_set.save
+      assert_equal([@answer], @rule_set.answers)
+    end
+
+    def test_answers_expand_when_answer_added_to_rule
+      @rule_set.rule = 'a1 and a2'
+      @rule_set.save
+      assert_equal([@answer, @other_answer], @rule_set.answers)
+    end
+
+    def test_rule_validation
+      @rule_set.rule = 'invalid'
+      @rule_set.save
+      assert(@rule_set.errors[:rule].present?, "there should be an error against the rule field")
+    end
+
+    private
+    def assert_no_rule_set_match(answers = nil)
+      assert(!@rule_set.match(answers), "should not return true if no match found")
+    end
+
+    def create_more_rule_sets
+      @rule_set_one = RuleSet.create(:title => 'One', :answers => [@answer], :url => 'http://undervale.co.uk')
+      @rule_set_two = RuleSet.create(:title => 'Two', :answers => [@other_answer], :url => 'http://undervale.com')
+    end
+
+    def create_custom_rule_set(rule)
+      @rule_set = RuleSet.create(:title => 'Custom', :rule => rule, :url => 'http://undervale.co.uk')
+    end
+
+  end
+  
+end

data/test/unit/qwester_test.rb

@@ -0,0 +1,33 @@
+require 'test_helper'
+
+class QwesterTest < ActiveSupport::TestCase
+  
+  def setup
+    Qwester.active_admin_menu = nil
+  end
+  
+  def test_qwester_set_up_as_a_module
+    assert_kind_of Module, Qwester
+  end
+  
+  def test_active_admin_load_path
+    expected = "#{Qwester::Engine.root}/lib/active_admin/admin"
+    assert_equal(expected, Qwester.active_admin_load_path)
+  end
+  
+  def test_active_admin_menu
+    assert_equal('Qwester', Qwester.active_admin_menu)
+  end
+  
+  def test_setting_active_admin_menu
+    text = 'Foo'
+    Qwester.active_admin_menu = text
+    assert_equal(text, Qwester.active_admin_menu)
+  end
+  
+  def test_active_admin_menu_none
+    Qwester.active_admin_menu = 'none'
+    assert_nil(Qwester.active_admin_menu)
+  end
+  
+end