surveyor_gui 0.0.3

data/spec/models/surveyor_gui/question_type_spec.rb

@@ -0,0 +1,268 @@
+# encoding: UTF-8
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe QuestionType do
+  let(:grid)    { FactoryGirl.create(:question_group, display_type: "grid") }
+  let(:inline)  { FactoryGirl.create(:question_group, display_type: "inline") }
+  let(:repeater){ FactoryGirl.create(:question_group, display_type: "inline") }
+
+  let(:textbox)         { FactoryGirl.create(
+                            :question,
+                            pick:             "none",
+                            display_type:     "default",
+                            question_group_id: nil
+                          )
+                        }
+  let(:textbox_a)       { FactoryGirl.create(
+                            :answer,
+                            question_id:    textbox.id,
+                            response_class: :text
+                          )
+                        }
+  let(:text)            { FactoryGirl.create(
+                           :question,
+                           pick:             "none",
+                           display_type:     "default",
+                           question_group_id: nil
+                          )
+                        }
+  let(:text_a)          { FactoryGirl.create(
+                            :answer,
+                            question_id:    text.id,
+                            response_class: :string
+                          )
+                        }
+  let(:float)           { FactoryGirl.create(
+                           :question,
+                           pick:             "none",
+                           display_type:     "default",
+                           question_group_id: nil
+                         )
+                        }
+  let(:float_a)         { FactoryGirl.create(
+                            :answer,
+                            question_id:    float.id,
+                            response_class: :float
+                          )
+                        }
+  let(:integer)         { FactoryGirl.create(
+                           :question,
+                           pick:             "none",
+                           display_type:     "default",
+                           question_group_id: nil
+                         )
+                        }
+  let(:integer_a)       { FactoryGirl.create(
+                            :answer,
+                            question_id:    integer.id,
+                            response_class: :integer
+                          )
+                        }
+  let(:date)            { FactoryGirl.create(
+                           :question,
+                           pick:             "none",
+                           display_type:     "default",
+                           question_group_id: nil
+                         )
+                        }
+  let(:date_a)          { FactoryGirl.create(
+                            :answer,
+                            question_id:    date.id,
+                            response_class: :date
+                          )
+                        }
+  let(:file)            { FactoryGirl.create(
+                           :question,
+                           pick:             "none",
+                           display_type:     "default",
+                           question_group_id: nil
+                         )
+                        }
+  let(:file_a)          { FactoryGirl.create(
+                            :answer,
+                            question_id:    file.id,
+                            response_class: :blob
+                          )
+                        }
+  let(:label)           { FactoryGirl.create(
+                           :question,
+                           pick:             "none",
+                           display_type:     "label",
+                           question_group_id: nil
+                         )
+                        }
+  let(:pick_one)        { FactoryGirl.create(
+                           :question,
+                           pick:             "one",
+                           display_type:      "default",
+                           question_group_id: nil
+                         )
+                        }
+  let(:pick_any)        { FactoryGirl.create(
+                           :question,
+                           pick:             "any",
+                           display_type:      "default",
+                           question_group_id: nil
+                         )
+                        }
+  let(:pick_one_inline) { FactoryGirl.create(
+                           :question,
+                           pick:             "one",
+                           display_type:      "default",
+                           question_group_id: inline.id
+                         )
+                        }
+  let(:pick_any_inline) { FactoryGirl.create(
+                           :question,
+                           pick:             "any",
+                           display_type:      "default",
+                           question_group_id: inline.id
+                         )
+                        }
+  let(:dropdown)        { FactoryGirl.create(
+                           :question,
+                           pick:             "one",
+                           display_type:      "dropdown",
+                           question_group_id: nil
+                         )
+                        }
+  let(:slider)          { FactoryGirl.create(
+                           :question,
+                           pick:             "one",
+                           display_type:      "slider",
+                           question_group_id: nil
+                         )
+                        }
+  let(:stars)           { FactoryGirl.create(
+                           :question,
+                           pick:             "one",
+                           display_type:      "stars",
+                           question_group_id: nil
+                         )
+                        }
+  let(:grid_one)        { FactoryGirl.create(
+                           :question,
+                           pick:             "one",
+                           display_type:      "default",
+                           question_group_id: grid.id
+                         )
+                        }
+  let(:grid_any)        { FactoryGirl.create(
+                           :question,
+                           pick:             "any",
+                           display_type:      "default",
+                           question_group_id: grid.id
+                         )
+                        }
+  let(:grid_dropdown)   { FactoryGirl.create(
+                           :question,
+                           pick:             "one",
+                           display_type:      "dropdown",
+                           question_group_id: grid.id
+                         )
+                        }
+  let(:group_inline)   { FactoryGirl.create(
+                           :question,
+                           pick:             "",
+                           display_type:      "",
+                           question_group_id: inline.id
+                         )
+                        }
+  let(:repeater)   { FactoryGirl.create(
+                           :question,
+                           pick:             "",
+                           display_type:      "",
+                           question_group_id: repeater.id
+                         )
+                        }
+
+
+  context "when categorizing question" do
+    before do
+      text.reload
+      text_a.reload
+      textbox.reload
+      textbox_a.reload
+      float.reload
+      float_a.reload
+      integer.reload
+      integer_a.reload
+      date.reload
+      date_a.reload
+      file.reload
+      file_a.reload
+    end
+
+    it "recognizes a textbox question" do
+      textbox.reload
+      textbox_a.reload
+      expect(textbox.question_type.id).to eql :box
+    end
+
+    it "recognizes a text question" do
+      expect(text.question_type.id).to eql :string
+    end
+
+    it "recognizes a float question" do
+      expect(float.question_type.id).to eql :number
+    end
+
+    it "recognizes an date question" do
+      expect(date.question_type.id).to eql :date
+    end
+
+    it "recognizes a file question" do
+      expect(file.question_type.id).to eql :file
+    end
+
+    it "recognizes a label" do
+      expect(label.question_type.id).to eql :label
+    end
+
+    it "recognizes a pick one question" do
+      expect(pick_one.question_type.id).to eql :pick_one
+    end
+
+    it "recognizes a pick any question" do
+      expect(pick_any.question_type.id).to eql :pick_any
+    end
+
+    it "recognizes an inline pick one question" do
+      expect(pick_one_inline.question_type.id).to eql :pick_one
+    end
+
+    it "recognizes an inline pick any question" do
+      expect(pick_any_inline.question_type.id).to eql :pick_any
+    end
+
+    it "recognizes a dropdown question" do
+      expect(dropdown.question_type.id).to eql :dropdown
+    end
+
+    it "recognizes a slider question" do
+      expect(slider.question_type.id).to eql :slider
+    end
+
+    it "recognizes a stars question" do
+      expect(stars.question_type.id).to eql :stars
+    end
+
+    it "recognizes a grid one question" do
+      expect(grid_one.question_type.id).to eql :grid_one
+    end
+
+    it "recognizes a grid any question" do
+      expect(grid_any.question_type.id).to eql :grid_any
+    end
+
+    it "recognizes a grid dropdown question" do
+      expect(grid_dropdown.question_type.id).to eql :grid_dropdown
+    end
+
+    it "recognizes a group inline question" do
+      expect(group_inline.question_type.id).to eql :group_inline
+    end
+
+  end
+
+end

data/spec/models/validation_condition_spec.rb

@@ -0,0 +1,98 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe ValidationCondition do
+  before(:each) do
+    @validation_condition = FactoryGirl.create(:validation_condition)
+  end
+
+  it "should be valid" do
+     @validation_condition.should be_valid
+  end
+  # this causes issues with building and saving
+  # it "should be invalid without a parent validation_id" do
+  #   @validation_condition.validation_id = nil
+  #   @validation_condition.should have(1).errors_on(:validation_id)
+  # end
+
+  it "should be invalid without an operator" do
+    @validation_condition.operator = nil
+    @validation_condition.should have(2).errors_on(:operator)
+  end
+
+  it "should be invalid without a rule_key" do
+    @validation_condition.should be_valid
+    @validation_condition.rule_key = nil
+    @validation_condition.should_not be_valid
+    @validation_condition.should have(1).errors_on(:rule_key)
+  end
+
+  it "should have unique rule_key within the context of a validation" do
+   @validation_condition.should be_valid
+   FactoryGirl.create(:validation_condition, :validation_id => 2, :rule_key => "2")
+   @validation_condition.rule_key = "2" #rule key uniquness is scoped by validation_id
+   @validation_condition.validation_id = 2
+   @validation_condition.should_not be_valid
+   @validation_condition.should have(1).errors_on(:rule_key)
+  end
+
+  it "should have an operator in Surveyor::Common::OPERATORS" do
+    Surveyor::Common::OPERATORS.each do |o|
+      @validation_condition.operator = o
+      @validation_condition.should have(0).errors_on(:operator)
+    end
+    @validation_condition.operator = "#"
+    @validation_condition.should have(1).error_on(:operator)
+  end
+end
+
+describe ValidationCondition, "validating responses" do
+  def test_var(vhash, ahash, rhash)
+    v = FactoryGirl.create(:validation_condition, vhash)
+    a = FactoryGirl.create(:answer, ahash)
+    r = FactoryGirl.create(:response, {:answer => a, :question => a.question}.merge(rhash))
+    return v.is_valid?(r)
+  end
+
+  it "should validate a response by regexp" do
+    test_var({:operator => "=~", :regexp => /^[a-z]{1,6}$/.to_s}, {:response_class => "string"}, {:string_value => "clear"}).should be_true
+    test_var({:operator => "=~", :regexp => /^[a-z]{1,6}$/.to_s}, {:response_class => "string"}, {:string_value => "foobarbaz"}).should be_false
+  end
+  it "should validate a response by integer comparison" do
+    test_var({:operator => ">", :integer_value => 3}, {:response_class => "integer"}, {:integer_value => 4}).should be_true
+    test_var({:operator => "<=", :integer_value => 256}, {:response_class => "integer"}, {:integer_value => 512}).should be_false
+  end
+  it "should validate a response by (in)equality" do
+    test_var({:operator => "!=", :datetime_value => Date.today + 1}, {:response_class => "date"}, {:datetime_value => Date.today}).should be_true
+    test_var({:operator => "==", :string_value => "foo"}, {:response_class => "string"}, {:string_value => "foo"}).should be_true
+  end
+  it "should represent itself as a hash" do
+    @v = FactoryGirl.create(:validation_condition, :rule_key => "A")
+    @v.stub(:is_valid?).and_return(true)
+    @v.to_hash("foo").should == {:A => true}
+    @v.stub(:is_valid?).and_return(false)
+    @v.to_hash("foo").should == {:A => false}
+  end
+end
+
+describe ValidationCondition, "validating responses by other responses" do
+  def test_var(v_hash, a_hash, r_hash, ca_hash, cr_hash)
+    ca = FactoryGirl.create(:answer, ca_hash)
+    cr = FactoryGirl.create(:response, cr_hash.merge(:answer => ca, :question => ca.question))
+    v = FactoryGirl.create(:validation_condition, v_hash.merge({:question_id => ca.question.id, :answer_id => ca.id}))
+    a = FactoryGirl.create(:answer, a_hash)
+    r = FactoryGirl.create(:response, r_hash.merge(:answer => a, :question => a.question))
+    return v.is_valid?(r)
+  end
+  it "should validate a response by integer comparison" do
+    test_var({:operator => ">"}, {:response_class => "integer"}, {:integer_value => 4}, {:response_class => "integer"}, {:integer_value => 3}).should be_true
+    test_var({:operator => "<="}, {:response_class => "integer"}, {:integer_value => 512}, {:response_class => "integer"}, {:integer_value => 4}).should be_false
+  end
+  it "should validate a response by (in)equality" do
+    test_var({:operator => "!="}, {:response_class => "date"}, {:datetime_value => Date.today}, {:response_class => "date"}, {:datetime_value => Date.today + 1}).should be_true
+    test_var({:operator => "=="}, {:response_class => "string"}, {:string_value => "donuts"}, {:response_class => "string"}, {:string_value => "donuts"}).should be_true
+  end
+  it "should not validate a response by regexp" do
+    test_var({:operator => "=~"}, {:response_class => "date"}, {:datetime_value => Date.today}, {:response_class => "date"}, {:datetime_value => Date.today + 1}).should be_false
+    test_var({:operator => "=~"}, {:response_class => "string"}, {:string_value => "donuts"}, {:response_class => "string"}, {:string_value => "donuts"}).should be_false
+  end
+end

data/spec/models/validation_spec.rb

@@ -0,0 +1,64 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Validation do
+  before(:each) do
+    @validation = FactoryGirl.create(:validation)
+  end
+
+  it "should be valid" do
+    @validation.should be_valid
+  end
+
+  it "should be invalid without a rule" do
+    @validation.rule = nil
+    @validation.should have(2).errors_on(:rule)
+    @validation.rule = " "
+    @validation.should have(1).errors_on(:rule)
+  end
+
+  # this causes issues with building and saving
+  # it "should be invalid without a answer_id" do
+  #   @validation.answer_id = nil
+  #   @validation.should have(1).error_on(:answer_id)
+  # end
+
+  it "should be invalid unless rule composed of only references and operators" do
+    @validation.rule = "foo"
+    @validation.should have(1).error_on(:rule)
+    @validation.rule = "1 to 2"
+    @validation.should have(1).error_on(:rule)
+    @validation.rule = "a and b"
+    @validation.should have(1).error_on(:rule)
+  end
+end
+describe Validation, "reporting its status" do
+  def test_var(vhash, vchashes, ahash, rhash)
+    a = FactoryGirl.create(:answer, ahash)
+    v = FactoryGirl.create(:validation, {:answer => a, :rule => "A"}.merge(vhash))
+    vchashes.each do |vchash|
+      FactoryGirl.create(:validation_condition, {:validation => v, :rule_key => "A"}.merge(vchash))
+    end
+    rs = FactoryGirl.create(:response_set)
+    r = FactoryGirl.create(:response, {:answer => a, :question => a.question}.merge(rhash))
+    rs.responses << r
+    return v.is_valid?(rs)
+  end
+
+  it "should validate a response by integer comparison" do
+    test_var({:rule => "A and B"}, [{:operator => ">=", :integer_value => 0}, {:rule_key => "B", :operator => "<=", :integer_value => 120}], {:response_class => "integer"}, {:integer_value => 48}).should be_true
+  end
+  it "should validate a response by regexp" do
+    test_var({}, [{:operator => "=~", :regexp => '/^[a-z]{1,6}$/'}], {:response_class => "string"}, {:string_value => ""}).should be_false
+  end
+end
+describe Validation, "with conditions" do
+  it "should destroy conditions when destroyed" do
+    @validation = FactoryGirl.create(:validation)
+    FactoryGirl.create(:validation_condition, :validation => @validation, :rule_key => "A")
+    FactoryGirl.create(:validation_condition, :validation => @validation, :rule_key => "B")
+    FactoryGirl.create(:validation_condition, :validation => @validation, :rule_key => "C")
+    v_ids = @validation.validation_conditions.map(&:id)
+    @validation.destroy
+    v_ids.each{|id| DependencyCondition.find_by_id(id).should == nil}
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,4 @@
+--colour
+--format progress
+--loadby mtime
+--reverse

data/spec/spec_helper.rb

@@ -0,0 +1,119 @@
+# This file is customized to run specs withing the testbed environemnt
+ENV["RAILS_ENV"] ||= 'test'
+begin
+  require File.expand_path("../../testbed/config/environment", __FILE__)
+rescue LoadError => e
+  fail "Could not load the testbed app. Have you generated it?\n#{e.class}: #{e}"
+end
+
+require 'rspec/rails'
+require 'rspec/autorun'
+
+require 'capybara/rails'
+require 'capybara/rspec'
+require 'capybara/poltergeist'
+require 'capybara/webkit'
+require 'factories'
+require 'json_spec'
+require 'database_cleaner'
+require 'rspec/retry'
+require 'rack/utils'
+
+# Requires supporting ruby files with custom matchers and macros, etc,
+# in spec/support/ and its subdirectories.
+Dir["./spec/support/**/*.rb"].sort.each {|f| require f}
+
+Capybara.app = Rack::ShowExceptions.new(Testbed::Application)
+# Checks for pending migrations before tests are run.
+# If you are not using ActiveRecord, you can remove this line.
+ActiveRecord::Migration.check_pending! if ::Rails.version >= "4.0" && defined?(ActiveRecord::Migration)
+
+
+Capybara.register_driver :poltergeist do |app|
+  Capybara::Poltergeist::Driver.new(app, debug: false)
+end
+
+Capybara.server_port = 3001
+Capybara.asset_host = "http://lvh.me:3001"
+
+Capybara.javascript_driver = :poltergeist
+
+RSpec.configure do |config|
+  config.include JsonSpec::Helpers
+  config.include SurveyorAPIHelpers
+  config.include SurveyorUIHelpers
+  config.include WaitForAjax
+
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+
+  # == Mock Framework
+  #
+  # If you prefer to use mocha, flexmock or RR, uncomment the appropriate line:
+  #
+  # config.mock_with :mocha
+  # config.mock_with :flexmock
+  # config.mock_with :rr
+  config.mock_with :rspec
+
+  # config.expect_with :rspec do |c|
+  #   c.syntax = :expect
+  # end
+
+  # Remove this line if you're not using ActiveRecord or ActiveRecord fixtures
+  config.fixture_path = "#{::Rails.root}/spec/fixtures"
+
+  # If you're not using ActiveRecord, or you'd prefer not to run each of your
+  # examples within a transaction, remove the following line or assign false
+  # instead of true.
+  config.use_transactional_fixtures = false
+
+  # If true, the base class of anonymous controllers will be inferred
+  # automatically. This will be the default behavior in future versions of
+  # rspec-rails.
+  config.infer_base_class_for_anonymous_controllers = false
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = "random"
+
+  # rspec-retry
+  # https://github.com/rspec/rspec-core/issues/456
+  config.verbose_retry       = true # show retry status in spec process
+  retry_count                = ENV['RSPEC_RETRY_COUNT']
+  config.default_retry_count = retry_count.try(:to_i) || 1
+  puts "RSpec retry count is #{config.default_retry_count}"
+
+  # host
+  config.before :each do
+  #  host = "lvh.me:"+Capybara.current_session.driver.server.port.to_s
+  ##  puts host
+  #  Capybara.asset_host = "http://#{host}"
+  #  Rails.application.routes.default_url_options[:host] = host
+  ##    #"lvh.me:"+Capybara.current_session.driver.server.port.to_s
+  end
+
+  # Database Cleaner
+  config.before :suite do
+    DatabaseCleaner.clean_with :truncation
+    DatabaseCleaner.strategy = :transaction
+  end
+
+  config.before :each do
+    if example.metadata[:clean_with_truncation] || example.metadata[:js]
+      DatabaseCleaner.strategy = :truncation
+    else
+      DatabaseCleaner.strategy = :transaction
+    end
+    DatabaseCleaner.start
+  end
+
+  config.after :each do
+    Capybara.reset_sessions!
+    DatabaseCleaner.clean
+  end
+end
+JsonSpec.configure do
+  exclude_keys "id", "created_at", "updated_at", "uuid", "modified_at", "completed_at"
+end