cloudfactory 0.5.6 → 0.6

data/lib/cf/cli/badge_yaml_validator.rb

@@ -0,0 +1,25 @@
+require 'pry'
+module Cf
+  module BadgeYamlValidator
+
+    def validate(yaml_path)
+      errors = []
+      badge_dump = YAML::load(File.read(yaml_path).strip)
+      if badge_dump.class == Hash
+        if badge_dump["badge"].class == Array
+          badge_dump["badge"].each do |badge|
+            errors << "form for the badge is missing" unless badge["form"]
+            errors << "name of the badge is missing"  unless badge["name"]
+            errors << "description for the badge is missing" unless badge["description"]
+            errors << "known answers for the badge must be array of hashes" unless badge["known_answers"].class == Array
+          end
+        else
+          errors << "badge mut be array of hash"
+        end
+      else
+        errors << "badges must be hash"
+      end
+      errors
+    end
+  end
+end

data/lib/cf/cli/line.rb

@@ -239,20 +239,14 @@ module Cf # :nodoc: all
           number = worker['num_workers']
           reward = worker['reward']
           worker_type = worker['worker_type']
+
+          ##### Add badge to the station ########
+
           if worker_type == "human"
-            skill_badges = worker['skill_badges']
+            badges = station_file['station']['badges']
             stat_badge = worker['stat_badge']
-            if stat_badge.nil?
-              human_worker = CF::HumanWorker.new({:station => s, :number => number, :reward => reward})
-            else
-              human_worker = CF::HumanWorker.new({:station => s, :number => number, :reward => reward, :stat_badge => stat_badge})
-            end
 
-            if worker['skill_badges'].present?
-              skill_badges.each do |badge|
-                human_worker.badge = badge
-              end
-            end
+            human_worker =  CF::HumanWorker.new({:station => s, :number => number, :reward => reward, :badge => badges, :stat_badge => stat_badge})
 
             say_status "worker", "#{number} Cloud #{pluralize(number, "Worker")} with reward of #{reward} #{pluralize(reward, "cent")}"
             display_error(line_title, "#{human_worker.errors}") if human_worker.errors.present?
@@ -266,6 +260,7 @@ module Cf # :nodoc: all
             display_error(line_title, "Invalid worker type: #{worker_type}")
           end
 
+
           # Creation of Form
           # Creation of TaskForm
           if station_file['station']['task_form'].present?
@@ -298,6 +293,15 @@ module Cf # :nodoc: all
             display_error(line_title, "#{form.errors}") if form.errors.present?
           end
 
+          # print if the badge for the station exist NOTE: addition of the badge is done above.
+          # it is printed here for better UI
+          if badges
+            say "Adding Badges For Station#{index}", :green
+            badges.each do |name|
+              say_status "-", "#{name}"
+            end
+          end
+
           #check the presence of gold standard and create goldstandards for the station
           gold_standards = station_file['station']['gold_standards']
           if gold_standards
@@ -323,29 +327,6 @@ module Cf # :nodoc: all
               end
             end
           end
-
-          #######create badge #########
-          badges = station_file['station']['badges']
-          if badges
-            say "Adding Badges to station", :green
-            badges.each do |s_badge|
-              if s_badge.length == 1 && s_badge.keys.include?("name")
-              else
-                form = s_badge["test_attributes"]["form_attributes"]
-                unless form.blank?
-                  if form["type"] == "CustomTaskForm"
-                    file = File.read("#{line_source}/#{form["file"]}") || File.read("#{line_source}/badges/station#{station_file['station']['station_index']}.html")
-                    s_badge["test_attributes"]["form_attributes"].merge!({:raw_html => file, :_type =>"CustomTaskForm" })
-                  else
-                    s_badge["test_attributes"]["form_attributes"].merge!({:_type =>"TaskForm" })
-                  end
-                end
-              end
-              badge = CF::Badge.new(s_badge.merge({:line => line,:station => s }))
-              say_status "Badge","'#{s_badge["name"] }'"
-              display_error(line_title, "#{badge.errors}") if badge.errors.present?
-            end
-          end
         end
       end
 
@@ -370,17 +351,17 @@ module Cf # :nodoc: all
           end
         end
         if gold_standards.class == Hash#gold_standards["file"]
-           gold_standard = CF::GoldStandard.new(gold_standards.merge!({:line => line}))
-           say_status "GoldStandard from file", "'#{gold_standards[:file]}'"
-           display_error(line_title, "#{gold_standard.errors}") if gold_standard.errors.present?
-        else
-        gold_standards.each do |gold_options|
-          gold_standard = CF::GoldStandard.new(gold_options.merge(:line => line))
-          say_status "GoldStandard", "'#{gold_options["name"]}'"
+          gold_standard = CF::GoldStandard.new(gold_standards.merge!({:line => line}))
+          say_status "GoldStandard from file", "'#{gold_standards[:file]}'"
           display_error(line_title, "#{gold_standard.errors}") if gold_standard.errors.present?
+        else
+          gold_standards.each do |gold_options|
+            gold_standard = CF::GoldStandard.new(gold_options.merge(:line => line))
+            say_status "GoldStandard", "'#{gold_options["name"]}'"
+            display_error(line_title, "#{gold_standard.errors}") if gold_standard.errors.present?
+          end
         end
       end
-      end
 
       say " ☁ ☁ ☁ ☁ ☁ ☁ ☁ ☁ ☁ ☁ ☁ ☁ ☁ ☁ ☁ ☁ ☁ ☁ ☁ ☁ ☁ ☁ ☁ ☁ ☁ ☁ ☁ ☁ ☁ ☁ ☁ ☁ ☁ ☁ ☁ ☁ ☁ ☁ ☁ ☁", :white
       say "Line was successfully created.", :green

data/lib/cf/cli/templates/sample-line/badge.yml

@@ -0,0 +1,21 @@
+badge:
+  - name: Designer                                          #name of the badge that you want to create
+    description: This badge allow to do the designing tasks #description of the badge
+    max_badge_assignments: 5                                #numbers of worker who can take the badge
+    retries_allowed: 5                                      #number of retries that worker get at the time of taking the badge
+    pass_percentage: 80                                     #the value in percentage that the worker must score to pass the test
+    assignment_duration: 3600                               #time assigned for badge test
+    check_manually: false                                   #checking badge answers that worker has ssubmitted
+    allow_retake_after: 30                                  #number of day after which the worker can again take the badge exam
+    form: badge_form.html                                   #form for the badge. It should be html format if it is a custom form
+    known_answers:                                          #the hash of question and answers for the badge
+      - input:
+          image_url: http://www.crystalinks.com/newton.jpg
+        expected_output:
+          gender: male
+          age: 60
+      - input:
+          image_url: http://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Salmanrampwalk.png/220px-Salmanrampwalk.png
+        expected_output:
+          gender: male
+          age: 50

data/lib/cf/cli/templates/sample-line/line.yml.erb

@@ -30,6 +30,8 @@ stations:
         worker_type: human    # "human" or name of robot (google_translate_robot, etc)
         num_workers: 2
         reward: 2
+      badge:
+         - bizcard-digitizer
       custom_task_form:
         form_title: Clink a link and paste in url
         instruction: Look through search results and find the best date

data/lib/cf/help.txt

@@ -65,3 +65,16 @@ Output:
     Get the output of run. For more info, cf output help
   More:
     cf output help [sub-command]                                                     #list all help related to output subcommands
+
+
+Badge:
+  Usage:
+    cf badge create                                                                  # Create badges that are in badge.yml
+    cf badge delete <badge name>                                                     # Delete the given badge within your account
+    cf badge generate                                                                # Generate a new badge template at badges/badge.yml
+    cf badge list                                                                    # List all badges asscociated with your account. Use 'cf badge list <badge_name>' for single badge
+    cf badge update <badge_name>                                                     # Update the given badge within with your account. Use 'cf badge update' to update all badges in badge.yml
+  Description:
+    Commands to manage the badges.
+  More:
+    cf help [COMMAND]                                                                # Describe subcommands or one specific subcommand

data/lib/cf/human_worker.rb

@@ -45,7 +45,7 @@ module CF
     attr_accessor :errors
 
     # Badge setting for "worker" object
-    attr_accessor :badge
+    attr_accessor :badges
 
     # ==Initializes a new "worker" object
     # ==Usage of HumanWorker.new(hash):
@@ -72,34 +72,26 @@ module CF
       @station = options[:station]
       @number  = options[:number].nil? ? 1 : options[:number]
       @reward  = options[:reward]
-      @stat_badge = options[:stat_badge].nil? ? nil : options[:stat_badge]
+      @stat_badge = options[:stat_badge]
+      @badges = options[:badge]
       if @station
-        if options[:stat_badge].nil?
-          request =
-          {
-            :body =>
-            {
-              :api_key => CF.api_key,
-              :worker => {:number => @number, :reward => @reward, :type => "HumanWorker"}
-            }
-          }
-        else
-          request =
+        request =
+        {
+          :body =>
           {
-            :body =>
-            {
-              :api_key => CF.api_key,
-              :worker => {:number => @number, :reward => @reward, :type => "HumanWorker"},
-              :stat_badge => options[:stat_badge]
-            }
+            :api_key => CF.api_key,
+            :worker => {:number => @number, :reward => @reward, :type => "HumanWorker"},
+            :badge => options[:badge],
+            :stat_badge => options[:stat_badge]
           }
-        end
+        }
         resp = HTTParty.post("#{CF.api_url}#{CF.api_version}/lines/#{CF.account_name}/#{@station.line['title'].downcase}/stations/#{@station.index}/workers.json",request)
 
         self.id =  resp.parsed_response['id']
         self.number =  resp.parsed_response['number']
         self.reward =  resp.parsed_response['reward']
         self.stat_badge =  resp.parsed_response['stat_badge']
+        self.badges = resp.parsed_response['badges']
 
         if resp.code != 200
           self.errors = resp.parsed_response['error']['message']
@@ -109,52 +101,8 @@ module CF
       end
     end
 
-    # ==Creation a new "worker" object with Badge
-    # ==Usage Example:
-    # ==In Plain Ruby way
-    #   badge_settings =
-    #   {
-    #       :title => 'Football Fanatic',
-    #       :description => "This qualification allows you to perform work at stations which have this badge.",
-    #       :max_badges => 3,
-    #       :test =>
-    #       {
-    #         :input => {:name => "Lionel Andres Messi", :country => "Argentina"},
-    #         :expected_output =>
-    #         [
-    #           {:birthplace => "Rosario, Santa Fe, Argentina",:match_options => {:tolerance => 10, :ignore_case => true }},
-    #           {:position => "CF",:match_options => {:tolerance => 1 }},
-    #           {:"current-club" => "Barcelona",:match_options => {:tolerance => 1, :ignore_case => false }}
-    #         ]
-    #       }
-    #   }
-    #   line = CF::Line.new("human_worker", "Digitization")
-    #   input_format = CF::InputFormat.new({:name => "image_url", :required => true, :valid_type => "url"})
-    #   line.input_formats input_format
-    #
-    #   station = CF::Station.new({:type => "work"})
-    #   line.stations station
-    #
-    #   worker = CF::HumanWorker.new({:number => 2, :reward => 20, :skill_badge => skill_badge})
-    #   line.stations.first.worker = worker
-    #
-    #   line.stations.first.worker.badge = badge_settings
-    def badge=(badge)
-      request =
-      {
-        :body =>
-        {
-          :api_key => CF.api_key,
-          :skill_badge => badge
-        }
-      }
-      resp = HTTParty.post("#{CF.api_url}#{CF.api_version}/lines/#{CF.account_name}/#{@station.line['title'].downcase}/stations/#{@station.index}/workers/#{self.id}/badge.json",request)
-      self.errors = resp['error']['message'] if resp.code != 200
-      self.skill_badges << resp.parsed_response['skill_badges']
-    end
-
     def to_s # :nodoc:
-      "{:id => => #{self.id}, :number => #{self.number}, :reward => #{self.reward}, :stat_badge => #{self.stat_badge}, :errors => #{self.errors}}"
+      "{:id => => #{self.id}, :number => #{self.number}, :reward => #{self.reward}, :stat_badge => #{self.stat_badge}, :errors => #{self.errors},:badges =>#{self.badges}}"
     end
   end
 end

data/lib/cf/station.rb

@@ -179,32 +179,26 @@ module CF
           number = worker_instance.number
           reward = worker_instance.reward
           stat_badge = worker_instance.stat_badge
-          if stat_badge.nil?
-            request =
-            {
-              :body =>
-              {
-                :api_key => CF.api_key,
-                :worker => {:number => number, :reward => reward, :type => "HumanWorker"}
-              }
-            }
-          else
-            request =
+          badges = worker_instance.badges
+
+          request =
+          {
+            :body =>
             {
-              :body =>
-              {
-                :api_key => CF.api_key,
-                :worker => {:number => number, :reward => reward, :type => "HumanWorker"},
-                :stat_badge => stat_badge
-              }
+              :api_key => CF.api_key,
+              :worker => {:number => number, :reward => reward, :type => "HumanWorker"},
+              :stat_badge => stat_badge,
+              :badge => badges
             }
-          end
+          }
+
           resp = HTTParty.post("#{CF.api_url}#{CF.api_version}/lines/#{CF.account_name}/#{self.line_title.downcase}/stations/#{self.index}/workers.json",request)
           worker = CF::HumanWorker.new({})
           worker.id =  resp.parsed_response['id']
           worker.number =  resp.parsed_response['number']
           worker.reward =  resp.parsed_response['reward']
           worker.stat_badge =  resp.parsed_response['stat_badge']
+          worker.badges =  resp.parsed_response['badges']
           if resp.code != 200
             worker.errors = resp.parsed_response['error']['message']
           end
@@ -373,45 +367,5 @@ module CF
     def gold_standards=(gold_standard) # :nodoc:
       @gold_standards << gold_standard
     end
-
-    #specify the badges for the station
-    # ===Usage Example:
-    # CF::Badge.new({:line => line, :station => s,:name => "Tomb Digitizer", :description    => "This badge qualifies you to work on tomb digitization tasks.",:max_badges     => 100,:gold_standards => ["#{@gold_standard.settings[:name]}"],:test_attributes =>{:type => "default",:retries => 10,:pass_percentage => 100,:check_manually => true}})
-    def badges badge = nil
-      line_title = line["title"] || line.title
-      if badge
-        if badge.settings[:test_attributes] && badge.settings[:test_attributes][:form_attributes].present?
-          form =  badge.settings[:test_attributes][:form_attributes]
-          if( form[:type] == "CustomTaskForm" && form[:file])
-            raw_html = ""
-            File.open("#{form[:file]}").each_line do |line|
-              raw_html += line
-            end
-            badge.settings[:test_attributes][:form_attributes].merge!({:raw_html => raw_html,:_type =>"CustomTaskForm"})
-          end
-          badge.settings[:test_attributes][:form_attributes].merge!({:_type =>"TaskForm"}) if form[:type] == "TaskForm"
-        end
-        request =
-        {
-          :body =>
-          {
-            :api_key => CF.api_key,
-            :badge => badge.settings
-          }
-        }
-        resp = HTTParty.post("#{CF.api_url}#{CF.api_version}/lines/#{CF.account_name}/#{line_title.downcase}/stations/#{self.index}/badges.json",request)
-        badge = CF::Badge.new()
-        badge.settings.merge!(resp.to_hash)
-        self.errors = resp.parsed_response['error']['message'] if resp.code != 200
-        @badges << badge
-      else
-        @badges
-      end
-    end
-
-    def badges=(badge)
-      @badges << badge
-    end
-
   end
 end

data/lib/cf/version.rb

@@ -1,3 +1,3 @@
 module CF # :nodoc: all
-  VERSION = "0.5.6"
+  VERSION = "0.6"
 end

data/spec/badges_spec.rb

@@ -1,342 +1,242 @@
 require 'spec_helper'
 
 describe CF::Badge do
-  context "add a badge" do
-    it "should add a badge to the station in DSL way" do
+  context "#create" do
+    it " in block DSL way" do
       WebMock.allow_net_connect!
-      title = "line_title#{Time.new.strftime('%Y%b%d-%H%M%S')}".downcase
-      sleep 1
-      line = CF::Line.create(title,"Digitization") do |l|
-        CF::InputFormat.new({:line => l, :name => "Company", :required => true, :valid_type => "general"})
-        CF::InputFormat.new({:line => l, :name => "Website", :required => true, :valid_type => "url"})
-      end
-      station = CF::Station.create({:line => line, :type => "work"}) do |s|
-        CF::HumanWorker.new({:station => s, :number => 1, :reward => 10})
-        CF::TaskForm.create({:station => s, :title => "Enter text from a business card image", :instruction => "Describe"}) do |i|
-          CF::FormField.new({:form => i, :label => "First Name", :field_type => "short_answer", :required => "true"})
-          CF::FormField.new({:form => i, :label => "Middle Name", :field_type => "short_answer"})
-          CF::FormField.new({:form => i, :label => "Last Name", :field_type => "short_answer", :required => "true"})
-        end
-        @gold_standard = CF::GoldStandard.new({ :line => line,
-          :station => s,
-          :name => "easy_#{Time.now}",
-          :input => {'image_url' => "http://onwired.com/images/portfolio/linda-stanley-business-card.jpg"},
-          :expected_output => {"first_name" => {"value" => "John"}, "last_name" => {"value" => "Lennon"}, "company" => {"value" => "Sprout"}}
-          })
-
-          @badge = CF::Badge.create({
-            :line => line,
-            :station => s,
-            :name           => "Tomb Digitizer#{Time.now.day}",
-            :description    => "This badge qualifies you to work on tomb digitization tasks.",
-            :max_badges     => 100,
-            :gold_standards => ["#{@gold_standard.settings[:name]}"],
-            :test_attributes =>
-            {
-              :type => "default",
-              :retries => 10,
-              :pass_percentage => 100,
-              :check_manually => true
-            }
-            })
-          end
-        end
-
-        it "should reuse the badge with in the account and  badge to the station in DSL way" do
-          WebMock.allow_net_connect!
-          title = "line_title#{Time.new.strftime('%Y%b%d-%H%M%S')}".downcase
-          sleep 1
-          line = CF::Line.create(title,"Digitization") do |l|
-            CF::InputFormat.new({:line => l, :name => "Company", :required => true, :valid_type => "general"})
-            CF::InputFormat.new({:line => l, :name => "Website", :required => true, :valid_type => "url"})
-          end
-          station = CF::Station.create({:line => line, :type => "work"}) do |s|
-            CF::HumanWorker.new({:station => s, :number => 1, :reward => 10})
-            CF::TaskForm.create({:station => s, :title => "Enter text from a business card image", :instruction => "Describe"}) do |i|
-              CF::FormField.new({:form => i, :label => "First Name", :field_type => "short_answer", :required => "true"})
-              CF::FormField.new({:form => i, :label => "Middle Name", :field_type => "short_answer"})
-              CF::FormField.new({:form => i, :label => "Last Name", :field_type => "short_answer", :required => "true"})
-            end
-            @gold_standard = CF::GoldStandard.new({ :line => line,
-              :station => s,
-              :name => "easy_#{Time.now}",
-              :input => {'image_url' => "http://onwired.com/images/portfolio/linda-stanley-business-card.jpg"},
-              :expected_output => {"first_name" => {"value" => "John"}, "last_name" => {"value" => "Lennon"}, "company" => {"value" => "Sprout"}}
-              })
-
-              @badge = CF::Badge.create({
-                :line => line,
-                :station => s,
-                :name           => "timromero#{Time.now.day}",
-                :description    => "This badge qualifies you to work on tomb digitization tasks.",
-                :max_badges     => 100,
-                :gold_standards => ["#{@gold_standard.settings[:name]}"],
-                :test_attributes =>
-                {
-                  :type => "default",
-                  :retries => 10,
-                  :pass_percentage => 100,
-                  :check_manually => true
-                }
-                })
-
-                @badge = CF::Badge.create({
-                  :line => line,
-                  :station => s,
-                  :name    => "Tomb Digitizer#{Time.now.day}"
-                  })
-              end
-            end
-
-
-        it "should add a badge to the station in plain ruby way" do
-          WebMock.allow_net_connect!
-          title = "line_title#{Time.new.strftime('%Y%b%d-%H%M%S')}".downcase
-          sleep 1
-          @line = CF::Line.create(title,"Digitization") do |l|
-            CF::InputFormat.new({:line => l, :name => "Company", :required => true, :valid_type => "general"})
-            CF::InputFormat.new({:line => l, :name => "Website", :required => true, :valid_type => "url"})
-          end
-          station = CF::Station.create({:line => @line, :type => "work"}) do |s|
-            CF::HumanWorker.new({:station => s, :number => 1, :reward => 10})
-            CF::TaskForm.create({:station => s, :title => "Enter text from a business card image", :instruction => "Describe"}) do |i|
-              CF::FormField.new({:form => i, :label => "First Name", :field_type => "short_answer", :required => "true"})
-              CF::FormField.new({:form => i, :label => "Middle Name", :field_type => "short_answer"})
-              CF::FormField.new({:form => i, :label => "Last Name", :field_type => "short_answer", :required => "true"})
-            end
-            @gold_standard = CF::GoldStandard.new({ :line => @line,
-              :station => s,
-              :name => "easy",
-              :input => {'image_url' => "http://onwired.com/images/portfolio/linda-stanley-business-card.jpg"},
-              :expected_output => {"first_name" => {"value" => "John"}, "last_name" => {"value" => "Lennon"}, "company" => {"value" => "Sprout"}}
-              })
-            end
-            badge = CF::Badge.new({
-              :name           => "Tomb Digitizereee#{Time.now}",
-              :description    => "This badge qualifies you to work on tomb digitization tasks.",
-              :max_badges     => 100,
-              :gold_standards => ["#{@gold_standard.settings[:name]}"],
-              :test_attributes =>
-              {
-                :type => "default",
-                :retries => 10,
-                :pass_percentage => 100,
-                :check_manually => false
-              }
-              })
-
-              @line.stations.first.badges badge
-               badge1 = CF::Badge.new({
-                  :name           => "timromero#{Time.now.day}"
-                  })
-              @line.stations.first.badges badge1
-              @line.stations.first.badges.count.should eql(2)
-              @line.stations.first.badges.last.settings["name"].should eql("timromero#{Time.now.day}")
-              @line.stations.first.badges.first.settings["name"].should eq(badge.settings[:name])
-              @line.stations.first.badges.first.settings['test']["form"].should eql({"_type"=>"TaskForm", "form_fields"=>[{"label"=>"First Name", "field_type"=>"short_answer", "required"=>true, "position"=>1}, {"label"=>"Middle Name", "field_type"=>"short_answer", "position"=>2}, {"label"=>"Last Name", "field_type"=>"short_answer", "required"=>true, "position"=>3}], "instruction"=>"Describe", "title"=>"Enter text from a business card image"})
-
-            end
-
-
-            it "should add a badge to the station with test form defined in DSL way" do
-              WebMock.allow_net_connect!
-              title = "line_title#{Time.new.strftime('%Y%b%d-%H%M%S')}".downcase
-              sleep 1
-              line = CF::Line.create(title,"Digitization") do |l|
-                CF::InputFormat.new({:line => l, :name => "Company", :required => true, :valid_type => "general"})
-                CF::InputFormat.new({:line => l, :name => "Website", :required => true, :valid_type => "url"})
-              end
-              station = CF::Station.create({:line => line, :type => "work"}) do |s|
-                CF::HumanWorker.new({:station => s, :number => 1, :reward => 10})
-                CF::TaskForm.create({:station => s, :title => "Enter text from a business card image", :instruction => "Describe"}) do |i|
-                  CF::FormField.new({:form => i, :label => "First Name", :field_type => "short_answer", :required => "true"})
-                  CF::FormField.new({:form => i, :label => "Middle Name", :field_type => "short_answer"})
-                  CF::FormField.new({:form => i, :label => "Last Name", :field_type => "short_answer", :required => "true"})
-                end
-                @gold_standard = CF::GoldStandard.new({ :line => line,
-                  :station => s,
-                  :name => "easy_#{Time.now}",
-                  :input => {'image_url' => "http://onwired.com/images/portfolio/linda-stanley-business-card.jpg"},
-                  :expected_output => {"first_name" => {"value" => "John"}, "last_name" => {"value" => "Lennon"}, "company" => {"value" => "Sprout"}}
-                  })
-
-                  @badge = CF::Badge.new({
-                    :line => line,
-                    :station => s,
-                    :name           => "Tomb Digitizer#{Time.now}",
-                    :description    => "This badge qualifies you to work on tomb digitization tasks.",
-                    :max_badges     => 100,
-                    :gold_standards => ["#{@gold_standard.settings[:name]}"],
-                    :test_attributes =>
-                    {
-                      :type => "default",
-                      :retries => 10,
-                      :pass_percentage => 100,
-                      :check_manually => true,
-                      :form_attributes => {
-                        :title => "Tombfinder Test",
-                        :instruction => "Look at the image of the tomb in the url given and answer the asked questions.",
-                        :type => "TaskForm",
-                        :form_fields_attributes =>
-                        [
-                          { "label" => "Last Name", "field_type" => "radio_button", 'option_values' => ["LEIGH", "IRVING", "GERTRUDE"] },
-                          { "label" => "Lizzie Year of Birth", "field_type" => "radio_button", 'option_values' => ["1873", "1933", "1896"] }
-                        ]
-                      }
-                    }
-                    })
-                  end
-                  line.stations.first.badges.first.settings[:test_attributes][:form_attributes][:type].should eql("TaskForm")
-                  line.stations.first.badges.first.settings[:test_attributes][:form_attributes][:form_fields_attributes].should eql([{"label"=>"Last Name", "field_type"=>"radio_button", "option_values"=>["LEIGH", "IRVING", "GERTRUDE"]}, {"label"=>"Lizzie Year of Birth", "field_type"=>"radio_button", "option_values"=>["1873", "1933", "1896"]}])
-                end
-
-
-
-                it "should add a badge to the station with customtaskform as a badge testform form defined in DSL way" do
-                  WebMock.allow_net_connect!
-                  title = "line_title#{Time.new.strftime('%Y%b%d-%H%M%S')}".downcase
-                  sleep 1
-                  line = CF::Line.create(title,"Digitization") do |l|
-                    CF::InputFormat.new({:line => l, :name => "Company", :required => true, :valid_type => "general"})
-                    CF::InputFormat.new({:line => l, :name => "Website", :required => true, :valid_type => "url"})
-                  end
-                  station = CF::Station.create({:line => line, :type => "work"}) do |s|
-                    CF::HumanWorker.new({:station => s, :number => 1, :reward => 10})
-                    CF::TaskForm.create({:station => s, :title => "Enter text from a business card image", :instruction => "Describe"}) do |i|
-                      CF::FormField.new({:form => i, :label => "First Name", :field_type => "short_answer", :required => "true"})
-                      CF::FormField.new({:form => i, :label => "Middle Name", :field_type => "short_answer"})
-                      CF::FormField.new({:form => i, :label => "Last Name", :field_type => "short_answer", :required => "true"})
-                    end
-                    @gold_standard = CF::GoldStandard.new({ :line => line,
-                      :station => s,
-                      :name => "easy_#{Time.now}",
-                      :input => {'image_url' => "http://onwired.com/images/portfolio/linda-stanley-business-card.jpg"},
-                      :expected_output => {"first_name" => {"value" => "John"}, "last_name" => {"value" => "Lennon"}, "company" => {"value" => "Sprout"}}
-                      })
-
-                      @badge = CF::Badge.new({
-                        :line => line,
-                        :station => s,
-                        :name           => "Tomb Digitizer#{Time.now}",
-                        :description    => "This badge qualifies you to work on tomb digitization tasks.",
-                        :max_badges     => 100,
-                        :gold_standards => ["#{@gold_standard.settings[:name]}"],
-                        :test_attributes =>
-                        {
-                          :type => "default",
-                          :retries => 10,
-                          :pass_percentage => 100,
-                          :check_manually => true,
-                          :form_attributes => {
-                            :title => "Custom TestForm",
-                            :instruction => "Look at the image of the tomb in the url given and answer the asked questions.",
-                            :type => "CustomTaskForm",
-                            :file =>"./spec/badges/station_1.html"
-                          }
-                        }
-                        })
-                      end
-                      line.stations.first.badges.first.settings[:test_attributes][:form_attributes][:type].should eql("CustomTaskForm")
-                    end
-
-
-                    it "should add a badge with defined custom_task_form as a badge test form in plain ruby way " do
-                      WebMock.allow_net_connect!
-                      title = "line_title#{Time.new.strftime('%Y%b%d-%H%M%S')}".downcase
-                      sleep 1
-                      @line = CF::Line.create(title,"Digitization") do |l|
-                        CF::InputFormat.new({:line => l, :name => "Company", :required => true, :valid_type => "general"})
-                        CF::InputFormat.new({:line => l, :name => "Website", :required => true, :valid_type => "url"})
-                      end
-                      station = CF::Station.create({:line => @line, :type => "work"}) do |s|
-                        CF::HumanWorker.new({:station => s, :number => 1, :reward => 10})
-                        CF::TaskForm.create({:station => s, :title => "Enter text from a business card image", :instruction => "Describe"}) do |i|
-                          CF::FormField.new({:form => i, :label => "First Name", :field_type => "short_answer", :required => "true"})
-                          CF::FormField.new({:form => i, :label => "Middle Name", :field_type => "short_answer"})
-                          CF::FormField.new({:form => i, :label => "Last Name", :field_type => "short_answer", :required => "true"})
-                        end
-                        @gold_standard = CF::GoldStandard.new({ :line => @line,
-                          :station => s,
-                          :name => "easy",
-                          :input => {'image_url' => "http://onwired.com/images/portfolio/linda-stanley-business-card.jpg"},
-                          :expected_output => {"first_name" => {"value" => "John"}, "last_name" => {"value" => "Lennon"}, "company" => {"value" => "Sprout"}}
-                          })
-                        end
-                        badge = CF::Badge.new({
-                          :name           => "Tomb Digitizer#{Time.now}",
-                          :description    => "This badge qualifies you to work on tomb digitization tasks.",
-                          :max_badges     => 100,
-                          :gold_standards => ["#{@gold_standard.settings[:name]}"],
-                          :test_attributes =>
-                          {
-                            :type => "default",
-                            :retries => 10,
-                            :pass_percentage => 100,
-                            :check_manually => false,
-                            :form_attributes => {
-                              :title => "Custom TestForm in plain ruby way",
-                              :instruction => "Look at the image of the tomb in the url given and answer the asked questions.",
-                              :type => "CustomTaskForm",
-                              :file =>"./spec/badges/station_1.html"
-                            }
-                          }
-                          })
-                          @line.stations.first.badges badge
-                          @line.stations.first.badges.first.settings["test"]["form"]["_type"].should eql("CustomTaskForm")
-                          @line.stations.first.badges.first.settings["test"]["form"]["raw_html"].present?.should eql(true)
-                        end
-
-
-                        it "should add a badge with defined task_form as a badge test form in plain ruby way " do
-                          WebMock.allow_net_connect!
-                          title = "line_title#{Time.new.strftime('%Y%b%d-%H%M%S')}".downcase
-                          sleep 1
-                          @line = CF::Line.create(title,"Digitization") do |l|
-                            CF::InputFormat.new({:line => l, :name => "Company", :required => true, :valid_type => "general"})
-                            CF::InputFormat.new({:line => l, :name => "Website", :required => true, :valid_type => "url"})
-                          end
-                          station = CF::Station.create({:line => @line, :type => "work"}) do |s|
-                            CF::HumanWorker.new({:station => s, :number => 1, :reward => 10})
-                            CF::TaskForm.create({:station => s, :title => "Enter text from a business card image", :instruction => "Describe"}) do |i|
-                              CF::FormField.new({:form => i, :label => "First Name", :field_type => "short_answer", :required => "true"})
-                              CF::FormField.new({:form => i, :label => "Middle Name", :field_type => "short_answer"})
-                              CF::FormField.new({:form => i, :label => "Last Name", :field_type => "short_answer", :required => "true"})
-                            end
-                            @gold_standard = CF::GoldStandard.new({ :line => @line,
-                              :station => s,
-                              :name => "easy",
-                              :input => {'image_url' => "http://onwired.com/images/portfolio/linda-stanley-business-card.jpg"},
-                              :expected_output => {"first_name" => {"value" => "John"}, "last_name" => {"value" => "Lennon"}, "company" => {"value" => "Sprout"}}
-                              })
-                            end
-                            badge = CF::Badge.new({
-                              :name           => "Tomb Digitizer#{Time.now}",
-                              :description    => "This badge qualifies you to work on tomb digitization tasks.",
-                              :max_badges     => 100,
-                              :gold_standards => ["#{@gold_standard.settings[:name]}"],
-                              :test_attributes =>
-                              {
-                                :type => "default",
-                                :retries => 10,
-                                :pass_percentage => 100,
-                                :check_manually => false,
-                                :form_attributes => {
-                                  :title => "Tombfinder Test plain ruby way",
-                                  :instruction => "Look at the image of the tomb in the url given and answer the asked questions.",
-                                  :type => "TaskForm",
-                                  :form_fields_attributes =>
-                                  [
-                                    { "label" => "Last Name", "field_type" => "radio_button", 'option_values' => ["LEIGH", "IRVING", "GERTRUDE"] },
-                                    { "label" => "Lizzie Year of Birth", "field_type" => "radio_button", 'option_values' => ["1873", "1933", "1896"] }
-                                  ]
-                                }
-                              }
-                              })
-                              @line.stations.first.badges badge
-                              @line.stations.first.badges.first.settings["test"]["form"]["_type"].should eql("TaskForm")
-                              @line.stations.first.badges.first.settings["test"]["form"]["form_fields"].should eql([{"label"=>"Last Name", "field_type"=>"radio_button", "option_values"=>["LEIGH", "IRVING", "GERTRUDE"]}, {"label"=>"Lizzie Year of Birth", "field_type"=>"radio_button", "option_values"=>["1873", "1933", "1896"]}])
-
-                            end
+      @badge = CF::Badge.create(
+       :name => "Bizcard Digitizer_dsl",
+       :description => "this badge qualifies the worker for bizcard digitization",
+       :max_badge_assignments => 100,
+       :retries_allowed => 5,
+       :pass_percentage => 80,
+       :assignment_duration => 3600,
+       :allow_retake_after => 5,
+       :check_manually =>false,
+       :form => "./lib/cf/cli/templates/sample-line/form.html",
+       :known_answers=>
+       [
+         { "name" => "chandra",
+           "input"=> {"image_url"=> "http://onwired.com/images/portfolio/linda-stanley-business-card.jpg"},
+           "expected_output"=>{"gender"=>{"value"=>"Male"}, "rich"=>{"value"=>"1"}}
+         },
+        {
+          "name" => "mohan",
+          "input"=>{"image_url"=> "http://onwired.com/images/portfolio/linda-stanley-business-card.jpg2"},
+          "expected_output"=>{"gender"=>{"value"=>"Male"}, "rich"=>{"value"=>"2"}}
+        }
+       ]
+       )
+    end
+
+    it "in plain ruby way" do
+      WebMock.allow_net_connect!
+      @badge = CF::Badge.new(
+       :name => "Bizcard Digitizer_plain",
+       :description => "this badge qualifies the worker for bizcard digitization",
+       :max_badge_assignments => 100,
+       :retries_allowed => 5,
+       :pass_percentage => 80,
+       :assignment_duration => 3600,
+       :allow_retake_after => 5,
+       :check_manually =>false,
+       :form => "./lib/cf/cli/templates/sample-line/form.html",
+       :known_answers=>
+       [
+         { "name" => "chandra",
+           "input"=> {"image_url"=> "http://onwired.com/images/portfolio/linda-stanley-business-card.jpg"},
+           "expected_output"=>{"gender"=>{"value"=>"Male"}, "rich"=>{"value"=>"1"}}
+         },
+        {
+          "name" => "mohan",
+          "input"=>{"image_url"=> "http://onwired.com/images/portfolio/linda-stanley-business-card.jpg2"},
+          "expected_output"=>{"gender"=>{"value"=>"Male"}, "rich"=>{"value"=>"2"}}
+        }
+       ]
+       )
+    end
+
+    it " with standard task form" do
+      WebMock.allow_net_connect!
+      @badge = CF::Badge.create(
+       :name => "Bizcard Digitizer_standard_form",
+       :description => "this badge qualifies the worker for bizcard digitization",
+       :max_badge_assignments => 100,
+       :retries_allowed => 5,
+       :pass_percentage => 80,
+       :assignment_duration => 3600,
+       :allow_retake_after => 5,
+       :check_manually =>false,
+       :form => {:title => "standard task form", :instruction => "Describe me"},
+       :known_answers=>
+       [
+         { "name" => "chandra",
+           "input"=> {"image_url"=> "http://onwired.com/images/portfolio/linda-stanley-business-card.jpg"},
+           "expected_output"=>{"gender"=>{"value"=>"Male"}, "rich"=>{"value"=>"1"}}
+         },
+        {
+          "name" => "mohan",
+          "input"=>{"image_url"=> "http://onwired.com/images/portfolio/linda-stanley-business-card.jpg2"},
+          "expected_output"=>{"gender"=>{"value"=>"Male"}, "rich"=>{"value"=>"2"}}
+        }
+       ]
+       )
+    end
+
+  end
+
+  context "create a badge without" do
+   before(:each) do
+      WebMock.allow_net_connect!
+      @badge_hash = {
+         :name => "Bizcard Digitizer#{Time.new.strftime('%Y%b%d-%H%M%S')}",
+         :description => "this badge qualifies the worker for bizcard digitization",
+         :max_badge_assignments => 100,
+         :retries_allowed => 5,
+         :pass_percentage => 80,
+         :assignment_duration => 3600,
+         :allow_retake_after => 5,
+         :check_manually =>false,
+         :form => "./lib/cf/cli/templates/sample-line/form.html",
+         :known_answers=>
+         [
+           { "name" => "chandra",
+             "input"=> {"image_url"=> "http://onwired.com/images/portfolio/linda-stanley-business-card.jpg"},
+             "expected_output"=>{"gender"=>{"value"=>"Male"}, "rich"=>{"value"=>"1"}}
+           },
+          {
+            "name" => "mohan",
+            "input"=>{"image_url"=> "http://onwired.com/images/portfolio/linda-stanley-business-card.jpg2"},
+            "expected_output"=>{"gender"=>{"value"=>"Male"}, "rich"=>{"value"=>"2"}}
+          }
+         ]
+      }
+    end
+
+
+    it "name should give error 'Name can't be blank'" do
+      @badge_hash.delete(:name)
+      badge = CF::Badge.new(@badge_hash)
+      badge.errors.should eql(["Name can't be blank"])
+    end
+
+    it "form should raise error 'Test is invalid'" do
+      @badge_hash.delete(:form)
+      badge = CF::Badge.new(@badge_hash)
+      badge.errors.should eql(["Test is invalid"])
+    end
+
+    it "known_answers should raise error 'You have not provided known answers for the badge'" do
+      @badge_hash.delete(:known_answers)
+      badge = CF::Badge.new(@badge_hash)
+      badge.errors.should eql("You have not provided known answers for the badge.")
+    end
+
+    it "form with different file type" do
+      @badge_hash[:form] = "./lib/cf/cli/templates/sample-line/badge.yml"
+      badge = CF::Badge.new(@badge_hash)
+      badge.errors.should eql(["Wrong type of file for the form."])
+    end
+  end
+
+
+  context "#update" do
+    before(:each) do
+       WebMock.allow_net_connect!
+       @badge = CF::Badge.create(
+       :name => "Bizcard Digitizer",
+       :description => "this badge qualifies the worker for bizcard digitization",
+       :max_badge_assignments => 100,
+       :retries_allowed => 5,
+       :pass_percentage => 80,
+       :assignment_duration => 3600,
+       :allow_retake_after => 5,
+       :check_manually =>false,
+       :form => "./lib/cf/cli/templates/sample-line/form.html",
+       :known_answers=>
+       [
+         { "name" => "chandra",
+           "input"=> {"image_url"=> "http://onwired.com/images/portfolio/linda-stanley-business-card.jpg"},
+           "expected_output"=>{"gender"=>{"value"=>"Male"}, "rich"=>{"value"=>"1"}}
+         },
+        {
+          "name" => "mohan",
+          "input"=>{"image_url"=> "http://onwired.com/images/portfolio/linda-stanley-business-card.jpg2"},
+          "expected_output"=>{"gender"=>{"value"=>"Male"}, "rich"=>{"value"=>"2"}}
+        }
+       ]
+       )
+
+      @badge_hash = {
+         :name => "Bizcard Digitizer_updated",
+         :description => "this badge qualifies the worker for bizcard digitization for next level",
+         :max_badge_assignments => 80,
+         :retries_allowed => 0,
+         :pass_percentage => 10,
+         :assignment_duration => 300,
+         :allow_retake_after => 2,
+         :check_manually => true,
+         :form => "./lib/cf/cli/templates/sample-line/form.html",
+         :known_answers=>
+         [
+          {
+            "name" => "updated",
+            "input"=>{"image_url"=> "http://onwired.com/images/portfolio/linda-stanley-business-card.jpg2"},
+            "expected_output"=>{"gender"=>{"value"=>"Male"}, "rich"=>{"value"=>"2"}}
+          }
+         ]
+      }
+    end
+
+    it "in block DSl Way" do
+      badge = CF::Badge.update("Bizcard Digitizer", @badge_hash)
+      badge["name"].should eql("bizcard-digitizer_updated")
+      badge["description"].should eql("this badge qualifies the worker for bizcard digitization for next level")
+      badge["max_badge_assignments"].should eql(80)
+      badge["test"]["retries"].should eql(0)
+      badge["test"]["check_manually"].should eql(true)
+      badge["test"]["pass_percentage"].should eql(10)
+      badge["test"]["known_answers"].should eql(1)
+    end
+
+    it "in  absence of form should raise error" do
+      @badge_hash.delete(:form)
+      badge = CF::Badge.update(@badge.name, @badge_hash)
+      badge["error"]["message"].should eql("Badge #{@badge.name.parameterize} can not be updated beacuse {:test=>[\"is invalid\"]}")
+    end
+
+  end
+
+  context "#list" do
+    it "should list all badges" do
+      WebMock.allow_net_connect!
+      badge = CF::Badge.list
+      badge["code"].should eql(200)
+    end
+
+    it "should list specific badge" do
+    WebMock.allow_net_connect!
+    badge_list = CF::Badge.list("bizcard-digitizer_updated")
+    badge_list["badges"].first["name"].should eql("bizcard-digitizer_updated")
+    end
+  end
+
+  context "#delete" do
+    it "a specific badge" do
+      WebMock.allow_net_connect!
+      badge = CF::Badge.destroy("bizcard-digitizer_updated")
+      badge["code"].should eql(200)
+      CF::Badge.list("bizcard-digitizer_updated")["error"]["message"].should eql("No badge to list")
+    end
 
-                          end
-                        end
+    it "delete all badges" do
+      WebMock.allow_net_connect!
+      badge2 = CF::Badge.destroy("bizcard-digitizer")
+      badge2 = CF::Badge.destroy("bizcard-digitizer_updated")
+      badge2 = CF::Badge.destroy("bizcard-digitizer_dsl")
+      badge3 = CF::Badge.destroy("bizcard-digitizer_plain")
+      badge4 = CF::Badge.destroy("Bizcard Digitizer_standard_form")
+    end
+
+  end
+end