lppexam 0.0.1

data/lib/exam.rb

@@ -0,0 +1,126 @@
+require "exam/version"
+
+# = exam.rb
+#
+# Autor:: Dailos Sabina Rodriguez
+# Autor:: Raul Perez Hernandez
+#
+#
+
+#Implementamos modulo Exam
+module Exam
+
+  # === Clase Pregunta
+  # Definición de la clase Pregunta que permite almacenar y representar una pregunta por pantalla, proporciona una interfaz de usuario y permite saber el nivel de la pregunta mediante una variable. Sus metodos son:
+  # * metodo <=>
+  # * metodo ==
+  # * metodo obtener_pregunta
+  # * metodo obtener_level
+  # * metodo obtener_respuestas
+  # * metodo obtener_correcta
+  # * metodo obtener_respuesta
+  # * metodo initiliaze
+  # * metodo to_s
+  class Pregunta
+    # Se incluye el modulo comparable para comparar diferentes niveles de preguntas
+    include Comparable
+
+    # Atributo answers, para almacenar las respuestas de la pregunta
+    # Atributo title, para almacenar la respuesta en si
+    # Atributo num_c, numero de la respuesta correcta
+    # Atributo level, nivel de la pregunta
+    attr_accessor :answers, :title, :num_c, :level
+
+    # Metodo para hacer uso del modulo Comparable comparando el nivel de dos preguntas
+    def <=> (anOther)
+      @level <=> anOther.level
+    end
+
+    # Metodo para comparar que una pregunta es igual a otra
+    def == (other)
+      @level == other.level && @title == other.title
+    end
+    
+    # Metodo para obtener el titulo de la pregunta mediante una introducción por pantalla
+    def self.obtener_pregunta
+      puts 'Introduzca la pregunta'
+      title = gets.chomp
+      return title
+    end
+
+    # Metodo para obtener el nivel de la pregunta
+    def self.obtener_level
+      print "Introduzca nivel de dificultad de la pregunta, 0 minimo y 10 maximo"
+      @level = gets.chomp.to_i
+    end
+
+    # Metodo para obtener las diferentes respuestas a la pregunta, manteniendo la suposición de que el numero de respuestas será el que nos proporcionen
+    def self.obtener_respuestas
+      puts "Introduzca numero de respuestas a la pregunta"
+      num = gets.chomp.to_i
+      c = []
+      while num != 0
+        c = c + obtener_respuesta(c.length + 1)
+        num -= 1
+      end
+      @answers = c
+    end
+
+    # Metodo para saber dentro de la clase Pregunta cual de las respuestas es la correcta, mediante un indice que apunta a un array
+    def self.obtener_correcta
+      puts "Introduzca el numero de la respuesta correcta"
+      @num_c = gets.chomp.to_i
+    end
+
+    # Metodo para obtener una respuesta simple a una pregunta
+    def self.obtener_respuesta(num)
+      puts "Introduzca la respuesta #{num}"
+      ans = [gets.chomp]
+      return ans
+    end
+
+    # Metodo para inicializar la clase
+    def initialize(title = obtener_pregunta, answers = obtener_respuestas, num_c = obtener_correcta, level = obtener_level)
+      raise ArgumentError,
+        "Title has to be a String, got #{title.class}" unless title.is_a? String
+      @title = title
+      @answers = answers
+      @num_c = num_c
+      @level = level
+    end
+
+    # Metodo para mostrar por pantalla la pregunta y las posibles respuestas
+    def to_s
+      out = "# #{@title}" + "\n"
+      i = 1
+      answers.each do |a|
+        out << " #{i}.- #{a}\n"
+        i += 1
+      end
+      out
+    end
+  end
+
+  # === Clase Pregunta_VF
+  # Definición de la clase Pregunta_VF que es hija de Pregunta y que constituye un caso particular de la clase Pregunta para preguntas de Verdadero y Falso. Hace uso de los metodos de Pregunta ademas de:
+  # * metodo initialize. Con overriding sobre el de Pregunta
+  # * metodo obtener_correcta. Con overriding sobre el de Pregunta
+  # Clase para representar la clase de preguntas de Verdadero y Falso
+  class Pregunta_VF < Pregunta
+
+    # Metodo para inicializar haciendo overriding
+    def initialize(title = obtener_pregunta, num_c = obtener_correcta, level = obtener_level)
+      raise ArgumenError, "Title has to be a String, got #{title.class}" unless title.is_a? String
+      @title = title
+      @answers = ["Cierto", "Falso"]
+      @num_c = num_c
+      @level = level
+    end
+  
+    # Metodo para obtener la respuesta correcta haciendo overriding
+    def self.obtener_correcta
+      puts "Si la respuesta es correcta teclee 0, en caso contrario teclee 1"
+      @num_c = gets.chomp.to_i
+    end
+  end
+end

data/lib/quiz_dsl.rb

@@ -0,0 +1,84 @@
+require_relative 'List'
+require_relative 'exam'
+require_relative 'Quiz'
+
+# = quiz_dsl.rb
+#
+# Autor:: Dailos Sabina Rodriguez
+# Autor:: Raul Perez Hernandez
+#
+#
+# === Clase QuizDSL
+# Definicion de la clase Quiz que permite representar un examen por pantalla mediante los siguientes metodos y tambien comprobar el resultado del examen, para ello hemos definido la clase como DSL
+# * metodo initialize
+# * metodo question
+# * metodo right
+# * metodo wrong
+#
+
+class QuizDSL < InterfazQuiz
+
+  # Metodo para inicializar la clase
+  def initialize(name = "", &block)
+    @aciertos = 0
+    @name = name
+    @questions = List.new
+    @wr = 0
+
+    if block_given?
+      if block.arity == 1
+        yield
+      else
+        instance_eval &block
+      end
+    end
+  end
+
+  # Metodo para cargar una pregunta haciendo uso de DSL
+  def question(title, answers = {})
+    resp = []
+    a = 0
+    num_c = 0
+    correcta = answers[:right] if answers[:right]
+    answers.map do |key,r|
+      resp << r
+      num_c = a if r == correcta
+      a += 1
+    end
+    @questions.ins_final(Exam::Pregunta.new(title, resp, num_c, 0))
+  end
+
+  # Metodo para cargar la respuesta correcta
+  def right
+    :right
+  end
+
+  # Metodo para cargar la/s respuesta/s errónea/s
+  def wrong
+    @wr += 1
+    ("wr"+@wr.to_s).intern
+  end
+end
+
+if __FILE__ == $0
+  quiz = QuizDSL.new("Cuestionario de LPP 05/12/2014") do
+    question '¿Cuantos argumentos de tipo bloque puede recibir un metodo?',
+      right => '1',
+      wrong => '2',
+      wrong => 'muchos',
+      wrong => 'los que defina el usuario'
+
+    question "En Ruby los bloque son objetos que contienen codigo",
+      wrong =>'Cierto',
+      right =>'Falso'
+    
+    question "Cual es el tipo del objeto en el siguiente codigo Ruby? class Objeto end",
+      wrong => 'Una constante',
+      wrong => 'Un objeto',
+      right => 'Una instancia de la clase Class',
+      wrong => 'Ninguna de las anteriores'
+  end
+  
+  #quiz.invertir
+  quiz.run
+end

data/spec/exam_spec.rb

@@ -0,0 +1,139 @@
+require 'spec_helper'
+require 'exam'
+require 'List'
+
+describe Exam do
+  before :each do
+    @p1 = Exam::Pregunta.new("Cuanto es 2 mas 2?", ["4", "3", "1"],0,2)
+    @p2 = Exam::Pregunta_VF.new("Es apropiado que una clase Tablero herede de una clase Juego",0,3)
+    @p3 = Exam::Pregunta.new("Cuanto es 3 mas 2?", ["5", "3", "1"],0,2)
+    @p4 = Exam::Pregunta_VF.new("Edison invento la bombilla?",0,5) 
+    @p5 = Exam::Pregunta.new("Cuanto es 2 mas 2?", ["4", "3", "1"], 0, 2)
+  end
+
+  it "Comprobar clase Pregunta" do
+    expect(@p1.is_a? Exam::Pregunta).to eq(true)
+  end
+  
+  it "Comprueba que una pregunta es de menor nivel que otra" do
+    expect(@p1 < @p2).to eq(true)
+    expect(@p2 < @p1).to eq(false)
+  end
+
+  it "Comprueba que una pregunta es de mismo nivel que otra" do
+    expect(@p1 == @p3).to eq(false)
+    expect(@p1 == @p5).to eq(true)
+  end
+
+  it "Comprueba que una pregunta es de mayor nivel que otra" do
+    expect(@p4 > @p1).to eq(true)
+  end
+
+  it "Debe existir un nivel de pregunta y debe estar entre 0 y 10" do
+    expect (@p1.level >= 0 && @p1.level <= 10)
+  end
+
+  it "Comprobar herencia de la clase Pregunta_VF" do
+    expect(@p2.is_a? Exam::Pregunta).to eq(true)
+  end
+  
+  
+  it "Comprobar instancia de Pregunta_VF" do
+    expect(@p2).to be_an_instance_of (Exam::Pregunta_VF)
+  end
+
+  it "Debe existir una pregunta" do
+    expect(@p1.title).not_to be_empty
+    expect(@p2.title).not_to be_empty
+  end
+
+  it "Deben existir opciones de respuestas" do
+    expect(@p1.answers).not_to be_empty
+    expect(@p2.answers).not_to be_empty
+  end
+
+  it "Se debe invocar a un metodo para obtener la pregunta" do
+    expect(@p1.respond_to? :obtener_pregunta)
+    expect(@p2.respond_to? :obtener_pregunta)
+  end
+         
+  it "Se debe invocar a un metodo para obtener las opciones de respuesta" do
+    expect(@p1.respond_to? :obtener_respuestas)
+    expect(@p2.respond_to? :obtener_respuestas)
+  end
+        
+  it "Debe existir al menos una respuesta correcta" do
+    expect(@p1.num_c != nil)
+    expect(@p2.num_c != nil)
+  end    
+
+  it "Se debe mostrar por la consola la pregunta y las opciones de respuesta" do
+    expect(@p1.respond_to? :to_s)  
+    expect(@p2.respond_to? :to_s)  
+  end
+  
+  it "Solo existen 2 respuestas: Verdadero o Falso" do
+    expect(@p2.answers.size == 2 && @p2.answers == ["Cierto", "Falso"])
+  end
+end
+
+describe Node do
+  before :each do
+    @t1 = List.new
+    @t1.ins_inicio(1)
+    @t1.ins_inicio(2)
+  end
+
+  it 'Debe existir un Nodo de la lista con sus datos y su siguiente' do
+    expect(@t1.head.dev_value != nil && @t1.head.dev_sig != nil)
+  end
+end
+
+describe List do
+  before :each do
+    @t1 = List.new
+    @t1.ins_inicio(1)
+    @t1.ins_final(2)
+    @t1.ins_inicio(4)
+  end
+
+  it 'Se extrae el primer elemento de la lista' do
+    l = @t1.length
+    @t1.sup_inicio
+    expect(@t1.length + 1 == l)
+  end
+
+  it "El maximo debe ser 4" do
+    expect(@t1.max == 4).to eq(true)
+  end
+
+  it "El minimo debe ser 1" do
+    expect(@t1.min == 1).to eq(true)
+  end
+
+  it "Comprueba el numero de elementos de la lista" do
+    expect(@t1.count).to eq(3)
+  end
+
+  it "Comprueba que hay un elemento en la lista" do
+    expect(@t1.include?(4)).to eq(true)
+  end
+
+  it 'Se puede insertar un elemento' do
+    l = @t1.length
+    @t1.ins_inicio(2)
+    expect(@t1.length - 1 == l)
+  end
+
+  it 'Se pueden insertar varios elementos' do
+    l = @t1.length
+    @t1.ins_inicio(3)
+    @t1.ins_inicio(4)
+    @t1.ins_final(5)
+    expect(@t1.length - 3 == l)
+  end
+
+  it 'Debe existir una lista con su cabeza' do
+    expect(@t1.count >= 1).to eq(true)
+  end
+end

data/spec/list_exam_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+require 'exam'
+require 'List'
+
+describe Exam do
+  before :each do
+    @l1 = List.new
+    @l1.ins_inicio(Exam::Pregunta.new('¿Cual es la salida del siguiente codigo Ruby? class Xyz def pots @nice end end xyz = Xyz.new p xyz.pots', ['#<Xyz:0xa000208>', 'nil', '0', 'Ninguna de las anteriores'], 1, 0))
+    @l1.ins_final(Exam::Pregunta.new('La siguiente definicion de un hash en Ruby es validad: hash_raro = { [1, 2, 3] => Object.new(), Hash.new => :toto }', ['Cierto', 'Falso'], 0, 1))
+    @l1.ins_final(Exam::Pregunta.new('Cual es la salida del siguiente codigo Ruby? class Array def say_hi "HEY!" end end p [1, "bob"].say_hi', ['1', 'bob', 'HEY!', 'Ninguna de las anteriores'], 2, 2))
+    @l1.ins_final(Exam::Pregunta.new('Cual es el tipo del objeto en el siguiente codigo Ruby? class Objeto end', ['Una instancia de la clase Class', 'Una constante', 'Un objeto', 'Ninguna de las anteriores'], 0, 3))
+    @l1.ins_final(Exam::Pregunta_VF.new('Es apropiado que una clase Tablero herede de una clase Juego', 0, 4))
+    @l1.ins_final(Exam::Pregunta.new('¿Cual es la salida del siguiente codigo Ruby? class Xyz def pots @nice end end xyz = Xyz.new p xyz.pots', ['#<Xyz:0xa000208>', 'nil', '0', 'Ninguna de las anteriores'], 1, 0))
+  end
+
+  it "Debe existir una pregunta" do
+    p = @l1.head
+    while p.dev_sig != nil
+      expect(p.dev_value.title).not_to be_empty
+      p = p.dev_sig
+    end
+  end
+
+  it "Deben existir opciones de respuestas" do
+    p = @l1.head
+    while p.dev_sig != nil
+      expect(p.dev_value.answers).not_to be_empty
+      p = p.dev_sig
+    end
+  end
+
+  it "Se debe invocar a un metodo para obtener la pregunta" do
+    p = @l1.head
+    while p.dev_sig != nil
+      expect(p.dev_value.respond_to? :obtener_pregunta)
+      p = p.dev_sig
+    end
+  end
+         
+  it "Se debe invocar a un metodo para obtener las opciones de respuesta" do
+    p = @l1.head
+    while p.dev_sig != nil
+      expect(p.dev_value.respond_to? :obtener_respuestas)
+      p = p.dev_sig
+    end
+  end
+        
+  it "Debe existir al menos una respuesta correcta" do
+    p = @l1.head
+    while p.dev_sig != nil
+      expect(p.dev_value.num_c != nil)
+      p = p.dev_sig
+    end
+  end    
+
+  it "Se debe mostrar por la consola la pregunta y las opciones de respuesta" do
+    p = @l1.head
+    while p.dev_sig != nil
+      expect(p.dev_value.respond_to? :to_s)  
+      p = p.dev_sig
+    end
+  end
+  
+  it "Comprueba el numero de elementos de la lista" do
+    expect(@l1.count).to eq(6)
+  end
+
+  it "Comprobar que una pregunta es igual a otra" do
+    expect(@l1.head.dev_value == @l1.tail.dev_value).to eq(true)
+  end
+
+  it "Comprobar clase Pregunta" do
+    expect((@l1.head.dev_value).is_a? Exam::Pregunta).to eq(true)
+  end
+
+  it "Comprueba que una pregunta es de menor nivel que otra" do
+    expect(@l1.head.dev_value < @l1.head.dev_sig.dev_value).to eq(true)
+    expect(@l1.head.dev_sig.dev_value < @l1.head.dev_value).to eq(false)
+  end 
+end

data/spec/quiz_dsl_spec.rb

@@ -0,0 +1,131 @@
+require 'spec_helper'
+require 'exam'
+require 'List'
+require 'Quiz'
+require 'quiz_dsl'
+
+describe QuizDSL do
+  before :each do
+    @q1 = QuizDSL.new("Cuestionario de LPP 05/12/2014") {
+      question '¿Cuantos argumentos de tipo bloque puede recibir un metodo?',
+        right => '1',
+        wrong => '2',
+        wrong => 'muchos',
+        wrong => 'los que defina el usuario'
+
+      question "En Ruby los bloque son objetos que contienen codigo",
+        wrong =>'Cierto',
+        right =>'Falso'
+    
+      question "Cual es el tipo del objeto en el siguiente codigo Ruby? class Objeto end",
+        wrong => 'Una constante',
+        wrong => 'Un objeto',
+        right => 'Una instancia de la clase Class',
+        wrong => 'Ninguna de las anteriores'
+    }
+  end
+  
+  it "Se debe poder leer las preguntas" do
+    expect(@q1.respond_to? :question)
+  end
+
+  it "Se debe poder leer la respuesta correcta" do
+    expect(@q1.respond_to? :right)
+  end
+  
+  it "Se debe poder leer las respuestas erroneas" do
+    expect(@q1.respond_to? :wrong)
+  end
+  
+  it "Se crea bien el examen" do
+    expect(@q1.name) == "Cuestionario de LPP 05/12/2014"
+  end
+  
+  it "Se debe poder invertir el orden de las preguntas" do
+    expect(@q1.respond_to? :invertir)
+  end
+
+  it "Se debe poder realizar por pantalla un examen" do
+    expect(@q1.respond_to? :run)
+  end
+
+  it "Se debe poder mostrar por pantalla un examen" do
+    expect(@q1.respond_to? :to_s)
+  end
+  
+  it "Se debe poder corregir un examen" do
+    expect(@q1.respond_to? :check)
+  end
+
+  it "Debe existir alguna pregunta en el examen" do
+    expect(@q1.questions.count >= 1).to eq(true)
+  end
+
+  it "Comprobar que no hay preguntas iguales" do
+    p1 = @q1.questions.head
+    while p1.dev_sig != nil
+      p2 = p1.dev_sig
+      while p2 != nil
+        expect(p1.dev_value == p2.dev_value).to eq(false)
+        p2 = p2.dev_sig
+      end
+      p1 = p1.dev_sig
+    end
+  end
+  
+  it "Examen perfecto" do
+    expect(@q1.check([0, 1, 2])).to eq(3)
+  end
+  
+  it "Examen aprobado" do
+    expect(@q1.check([1, 1, 2])).to be >= 2
+  end
+  
+  it "Examen suspenso" do
+    expect(@q1.check([0, 0, 1])).to be < 2
+  end
+
+  it "Deben existir opciones de respuestas" do
+    p = @q1.questions.head
+    while p.dev_sig != nil
+      expect(p.dev_value.answers).not_to be_empty
+      p = p.dev_sig
+    end
+  end
+
+  it "Se debe invocar a un metodo para obtener la pregunta" do
+    p = @q1.questions.head
+    while p.dev_sig != nil
+      expect(p.dev_value.respond_to? :obtener_pregunta)
+      p = p.dev_sig
+    end
+  end
+
+  it "Se debe invocar a un metodo para obtener las opciones de respuesta" do
+    p = @q1.questions.head
+    while p.dev_sig != nil
+      expect(p.dev_value.respond_to? :obtener_respuestas)
+      p = p.dev_sig
+    end
+  end
+        
+  it "Debe existir al menos una respuesta correcta" do
+    p = @q1.questions.head
+    while p.dev_sig != nil
+      expect(p.dev_value.num_c != nil)
+      p = p.dev_sig
+    end
+  end    
+
+  it "Se debe mostrar por la consola la pregunta y las opciones de respuesta" do
+    p = @q1.questions.head
+    while p.dev_sig != nil
+      expect(p.dev_value.respond_to? :to_s)  
+      p = p.dev_sig
+    end
+  end
+  
+  it "Comprueba el numero de preguntas en el examen" do
+    expect(@q1.questions.count).to eq(3)
+  end
+end

data/spec/quiz_spec.rb

@@ -0,0 +1,117 @@
+require 'spec_helper'
+require 'exam'
+require 'List'
+require 'Quiz'
+
+describe Quiz do
+  before :each do
+    @l1 = List.new
+    @l1.ins_inicio(Exam::Pregunta.new('¿Cual es la salida del siguiente codigo Ruby? class Xyz def pots @nice end end xyz = Xyz.new p xyz.pots', ['#<Xyz:0xa000208>', 'nil', '0', 'Ninguna de las anteriores'], 1, 0))
+    @l1.ins_final(Exam::Pregunta.new('La siguiente definicion de un hash en Ruby es validad: hash_raro = { [1, 2, 3] => Object.new(), Hash.new => :toto }', ['Cierto', 'Falso'], 0, 1))
+    @l1.ins_final(Exam::Pregunta.new('Cual es la salida del siguiente codigo Ruby? class Array def say_hi "HEY!" end end p [1, "bob"].say_hi', ['1', 'bob', 'HEY!', 'Ninguna de las anteriores'], 2, 2))
+    @l1.ins_final(Exam::Pregunta.new('Cual es el tipo del objeto en el siguiente codigo Ruby? class Objeto end', ['Una instancia de la clase Class', 'Una constante', 'Un objeto', 'Ninguna de las anteriores'], 0, 3))
+    @l1.ins_final(Exam::Pregunta_VF.new('Es apropiado que una clase Tablero herede de una clase Juego', 0, 4))
+#@l1.ins_final(Exam::Pregunta.new('¿Cual es la salida del siguiente codigo Ruby? class Xyz def pots @nice end end xyz = Xyz.new p xyz.pots', ['#<Xyz:0xa000208>', 'nil', '0', 'Ninguna de las anteriores'], 1, 1))
+    @q1 = InterfazQuiz.new("Examen LPP", @l1)
+    @q2 = InterfazQuiz.new("Examen LPP invertido", @l1)
+    @q2.invertir
+  end
+
+  it "Se debe poder invertir el orden de las preguntas" do
+    expect(@q1.respond_to? :invertir)
+  end
+
+  it "Orden de preguntas invertido" do
+    expect(@q1.questions.head == @q2.questions.tail).to eq(true)
+    expect(@q2.questions.head == @q1.questions.tail).to eq(true)
+  end
+
+  it "Se debe poder realizar por pantalla un examen" do
+    expect(@q1.respond_to? :run)
+  end
+
+  it "Se debe poder mostrar por pantalla un examen" do
+    expect(@q1.respond_to? :to_s)
+  end
+  
+  it "Se debe poder corregir un examen" do
+    expect(@q1.respond_to? :check)
+  end
+
+  it "Debe existir alguna pregunta en el examen" do
+    expect(@q1.questions.count >= 1).to eq(true)
+  end
+
+  it "Comprobar que no hay preguntas iguales" do
+    p1 = @q1.questions.head
+    while p1.dev_sig != nil
+      p2 = p1.dev_sig
+      while p2 != nil
+        expect(p1.dev_value == p2.dev_value).to eq(false)
+        p2 = p2.dev_sig
+      end
+      p1 = p1.dev_sig
+    end
+  end
+  
+  it "Examen perfecto" do
+    expect(@q1.check([1, 0, 2, 0, 0])).to eq(5)
+  end
+  
+  it "Examen aprobado" do
+    expect(@q1.check([1, 0, 2, 1, 1])).to be >= 3
+  end
+  
+  it "Examen suspenso" do
+    expect(@q1.check([1, 1, 2, 1, 1])).to be < 3
+  end
+
+  it "Deben existir opciones de respuestas" do
+    p = @q1.questions.head
+    while p.dev_sig != nil
+      expect(p.dev_value.answers).not_to be_empty
+      p = p.dev_sig
+    end
+  end
+
+  it "Se debe invocar a un metodo para obtener la pregunta" do
+    p = @q1.questions.head
+    while p.dev_sig != nil
+      expect(p.dev_value.respond_to? :obtener_pregunta)
+      p = p.dev_sig
+    end
+  end
+
+  it "Se debe invocar a un metodo para obtener las opciones de respuesta" do
+    p = @q1.questions.head
+    while p.dev_sig != nil
+      expect(p.dev_value.respond_to? :obtener_respuestas)
+      p = p.dev_sig
+    end
+  end
+        
+  it "Debe existir al menos una respuesta correcta" do
+    p = @q1.questions.head
+    while p.dev_sig != nil
+      expect(p.dev_value.num_c != nil)
+      p = p.dev_sig
+    end
+  end    
+
+  it "Se debe mostrar por la consola la pregunta y las opciones de respuesta" do
+    p = @q1.questions.head
+    while p.dev_sig != nil
+      expect(p.dev_value.respond_to? :to_s)  
+      p = p.dev_sig
+    end
+  end
+  
+  it "Comprueba el numero de preguntas en el examen" do
+    expect(@q1.questions.count).to eq(5)
+  end
+
+  it "Comprueba que una pregunta es de menor nivel que otra" do
+    expect(@q1.questions.head.dev_value < @q1.questions.head.dev_sig.dev_value).to eq(true)
+    expect(@q1.questions.head.dev_sig.dev_value < @q1.questions.head.dev_value).to eq(false)
+  end 
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+require 'coveralls'
+Coveralls.wear!
+
+RSpec.configure do |config|
+#  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+#  config.filter_run :focus
+
+#  config.order = 'random'
+end