uptime_monitor 0.2.0 → 0.3.1

data/lib/uptime_monitor/maestro.treetop

@@ -0,0 +1,253 @@
+grammar Maestro
+
+  rule body
+    ( waiting  / validations_and_actions / element_validation / single_html_element / space)* {
+      def content
+        elements.map { |e| e.content }.compact
+      end
+
+      def description
+        elements.map { |e| e.description }.compact
+      end
+    }
+  end
+
+  rule waiting
+    space? "wait_for" page_content  {
+      def content
+        [{:wait_until_exists? => page_content.content }]
+      end
+      def description
+        "waited, #{page_content.description}"
+      end
+    }
+  end
+
+  rule page_content
+    space (validations_and_actions / element_validation /  html_element) space? {
+      def content
+        elements[1].content
+      end
+      def description
+        elements[1].description
+      end
+    }
+  end
+
+  rule validations_and_actions
+    (element_validation / html_element) check_func+ {
+      def content
+        this_content = elements.first.content
+        container = [(this_content.is_a?(Array) ? this_content.first  : this_content )]
+        elements.last.elements.each do |e|
+          container << e.content
+        end
+        container
+      end
+
+      def description
+        string = elements.first.description
+        elements.last.elements.each do |e|
+          element_description = e.description
+          string << ", " if element_description.include?("with text") || element_description.include?("includes text")
+          string << element_description
+        end
+        string
+      end
+    }
+  end
+
+  rule element_validation
+    html_element ".where" space? hash space? {
+      def content
+        [{html_element.content => hash.content }]
+      end
+      def description
+        "#{html_element.description}, with #{hash.description}"
+      end
+    }
+  end
+
+  rule check_func
+    "." (reserved_with_string / click ) {
+      def content
+        elements[1].content
+      end
+      def description
+        elements[1].description
+      end
+    }
+  end
+
+  rule click
+    "click" {
+      def content
+        [:click]
+      end
+      def description
+        ""
+      end
+    }
+  end
+
+  rule reserved_with_string
+    reserved_functions string_params  {
+      def content
+        [{reserved_functions.content => string_params.content }]
+      end
+      def description
+        if reserved_functions.description.include?("set") || reserved_functions.description.include?("select")
+          ""
+        else
+          "#{reserved_functions.description} #{string_params.description}"
+        end
+      end
+    }
+  end
+
+  rule reserved_functions
+    ("with_text" / "includes_text" / "set" / "select") {
+      def content
+        case text_value
+        when "with_text"
+          :text
+        when "includes_text"
+          :includes_text
+        when "set"
+          :set
+        when "select"
+          :select
+        end
+      end
+      def description
+        case text_value
+        when "with_text"
+          "with text"
+        when "includes_text"
+          "includes text"
+        when "set"
+          "set to"
+        when "select"
+          "select"
+        end
+      end
+    }
+  end
+
+  rule string_params
+    space? '(' space? string space? ')' {
+      def content
+        string.content
+      end
+      def description
+        string.description
+      end
+    }
+  end
+
+  rule hash
+    '(' hash_contents+ ')' {
+      def content
+        hash = {}
+        elements[1].elements.each do |e|
+          hash.merge!(e.content)
+        end
+        hash
+      end
+      def description
+        string = ""
+        count = 0
+        elements[1].elements.each do |e|
+          string << ", " if count > 0
+          string << e.description
+          count += 1
+        end
+        string
+      end
+    }
+  end
+
+  rule hash_contents
+    key_value_pair space? ','? space? {
+      def content
+        key_value_pair.content
+      end
+      def description
+        key_value_pair.description
+      end
+    }
+  end
+
+  rule key_value_pair
+    space? identifier space? ":" space? string space? {
+      def content
+        {identifier.content => string.content }
+      end
+      def description
+        "#{identifier.description}=#{string.description}"
+      end
+    }
+  end
+
+  rule single_html_element
+    word number {
+      def content
+        [text_value.to_sym]
+      end
+      def description
+        "#{text_value}"
+      end
+    }
+  end
+
+  rule html_element
+    word number {
+      def content
+        text_value.to_sym
+      end
+      def description
+        "#{text_value}"
+      end
+    }
+  end
+
+  rule identifier
+    word number {
+      def content
+        text_value.to_sym
+      end
+      def description
+        text_value
+      end
+    }
+  end
+
+  rule string
+    '"' (!'"' . / '\"')* '"' {
+      def content
+        eval text_value
+      end
+      def description
+        text_value
+      end
+    }
+  end
+
+  rule word
+    [A-Za-z_]+
+  end
+
+  rule number
+    ([0-9]+)?
+  end
+
+  rule space
+    [\s]+ {
+      def content
+      end
+
+      def description
+      end
+    }
+  end
+end

data/lib/uptime_monitor/maestro_broswer.rb

@@ -0,0 +1,20 @@
+module Hercules
+  module Maestro
+    class Browser
+      attr_reader :browser
+      attr_reader :parser
+      attr_reader :s_expr
+      def initialize(url, browser_name = "firefox", is_headless = false)
+        @parser = Hercules::UptimeMonitor::MaestroLangParser.new
+        @browser = Hercules::UptimeMonitor::Browser.new(url, browser_name, is_headless)
+      end
+      def exists?(script)
+        @s_expr = @parser.parse(script).first
+        @browser.exists? @s_expr
+      end
+      def close
+        @browser.close
+      end
+    end
+  end
+end

data/lib/uptime_monitor/parser.rb

@@ -0,0 +1,45 @@
+require 'treetop'
+
+module Hercules
+  module UptimeMonitor
+    class Parser
+      def self.parse(data, parser, description = false)
+        if data.respond_to? :read
+          data = data.read
+        end
+
+        ast = parser.parse data
+
+        if ast
+          return (description ? ast.description : ast.content)
+        else
+          parser.failure_reason =~ /^(Expected .+) after/m
+          raise(Hercules::UptimeMonitor::ParserSyntaxError.new(error: "syntax error"), "syntax error") if $1.blank?
+          message =
+          "#{$1.gsub("\n", '$NEWLINE')}:" << "\n" <<
+          data.lines.to_a[parser.failure_line - 1] << "\n" <<
+          "#{'~' * (parser.failure_column - 1)}^"
+          raise(Hercules::UptimeMonitor::ParserSyntaxError.new(error: message), message)
+        end
+      end
+    end
+
+    class MaestroLangParser
+      Treetop.load(File.expand_path(File.join(File.dirname(__FILE__), 'maestro')))
+      @@maestro_parser = MaestroParser.new
+      def parse(data, description = false)
+        Hercules::UptimeMonitor::Parser.parse(data, @@maestro_parser, description)
+      end
+    end
+
+    class BrowsersLangParser
+      Treetop.load(File.expand_path(File.join(File.dirname(__FILE__), 'browsers')))
+      @@browsers_parser = BrowsersParser.new
+      def parse(data)
+        Hercules::UptimeMonitor::Parser.parse(data, @@browsers_parser)
+      end
+    end
+
+    class ParserSyntaxError < StandardError; end
+  end
+end

data/lib/uptime_monitor/uptime_monitor.rb

@@ -6,6 +6,9 @@ module Ragios
       attr_reader :success
       attr_reader :screenshot_url
       attr_reader :has_screenshot
+      attr_reader :browser_info
+      attr_reader :s_expr
+      attr_reader :validations
 
       def initialize
         @test_result = ActiveSupport::OrderedHash.new
@@ -19,17 +22,20 @@ module Ragios
         raise(Hercules::UptimeMonitor::NoUrlProvided.new(error: message), message) if @monitor.url.nil?
         message = "A browser must be provided for uptime_monitor: #{@monitor.monitor}"
         raise(Hercules::UptimeMonitor::NoBrowserProvided.new(error: message), message) if @monitor.browser.nil?
+        @browser_info = Hercules::UptimeMonitor::BrowsersLangParser.new.parse(@monitor.browser)
         message = "A validation (exists?) must be provided for uptime_monitor: #{@monitor.monitor}"
         raise(Hercules::UptimeMonitor::NoValidationProvided.new(error: message), message) if @monitor.exists?.nil?
+        @s_expr = Hercules::UptimeMonitor::MaestroLangParser.new.parse(@monitor.exists?)
+        @validations = Hercules::UptimeMonitor::MaestroLangParser.new.parse(@monitor.exists?, description = true)
+        {ok: true}
       end
 
       def test_command?
         @result_set = []
         @success = true
         @has_screenshot = false
-        browser_reader = Hercules::UptimeMonitor::BrowserReader.new(@monitor.browser)
-        start_browser(@monitor.url, browser_reader.browser_name, browser_reader.headless)
-        exists(@monitor.exists?)
+        start_browser(@monitor.url, browser_info[:browser], !!browser_info[:headless] )
+        exists(@s_expr)
         @test_result = {results: @result_set}
         @test_result[:screenshot] = @screenshot_url if @has_screenshot
         close_browser
@@ -52,28 +58,28 @@ module Ragios
       end
 
       def exists(page_elements)
-        page_elements.each do |page_element|
-          if @browser.exists?(page_element) 
-            result!(page_element, true) 
-          else 
+        for i in 0..(page_elements.length - 1)
+          if @browser.exists?(page_elements[i])
+            result!(@validations[i], true)
+          else
             take_screenshot
-            result!(page_element, false)
+            result!(@validations[i], false)
           end
         end
       end
 
-      def result!(page_element, state)
+      def result!(validation, state)
         @success = false if state == false
-        result = state ? [page_element, "exists_as_expected"] : [page_element, "does_not_exist_as_expected"]
+        result = state ? [validation, "exists_as_expected"] : [validation, "does_not_exist_as_expected"]
         @result_set << result
       end
 
       def take_screenshot
-        if RAGIOS_HERCULES_ENABLE_SCREENSHOTS && not(@monitor.disable_screenshots) && not(@has_screenshot) 
-          @screenshot_url = @browser.capture_screenshot 
+        if RAGIOS_HERCULES_ENABLE_SCREENSHOTS && not(@monitor.disable_screenshots) && not(@has_screenshot)
+          @screenshot_url = @browser.capture_screenshot
           @has_screenshot = true
         end
-      end   
+      end
     end
   end
 end

data/spec/browsers_lang_parser_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Hercules::UptimeMonitor::BrowsersLangParser do
+  before(:all) do
+    @parser = Hercules::UptimeMonitor::BrowsersLangParser.new
+  end
+  it "parses valid browser names in the format - [\S]+" do
+    @parser.parse("firefox").should == {browser: "firefox", headless: false}
+    @parser.parse("   firefox ").should == {browser: "firefox", headless: false}
+    @parser.parse("_,0any_non_whitespace").should == {browser: "_,0any_non_whitespace", headless: false}
+  end
+  it "raises an exception for invalid browser name" do
+    expect { @parser.parse("\n") }.to raise_error
+    expect { @parser.parse(" ") }.to raise_error(Hercules::UptimeMonitor::ParserSyntaxError)
+  end
+  it "parses valid specification for headless browser operation" do
+    @parser.parse("firefox headless").should == {browser: "firefox", headless: true}
+    @parser.parse(" firefox headless ").should == {browser: "firefox", headless: true}
+    @parser.parse("   firefox    headless          ").should == {browser: "firefox", headless: true}
+
+    browser = <<-eos
+      chrome headless
+    eos
+    @parser.parse(browser).should == {browser: "chrome", headless: true}
+
+    browser = <<-eos
+      chrome
+
+      headless
+    eos
+    @parser.parse(browser).should == {browser: "chrome", headless: true}
+  end
+  it "raises an exception for invalid headless assignment" do
+    expect { @parser.parse("anybrowser invalid") }.to raise_error(Hercules::UptimeMonitor::ParserSyntaxError)
+  end
+end

data/spec/maestro_lang_parser_spec.rb

@@ -0,0 +1,153 @@
+require 'spec_helper'
+
+describe Hercules::UptimeMonitor::MaestroLangParser do
+  before(:all) do
+    @parser = Hercules::UptimeMonitor::MaestroLangParser.new
+  end
+  it "it returns correct s expression for html elements" do
+    validations = <<-eos
+      h1
+      div
+      anything
+    eos
+    @parser.parse(validations).should == [[:h1], [:div], [:anything]]
+  end
+  it "it returns correct description for html elements" do
+    validations = <<-eos
+      h1
+      div
+      anything
+    eos
+    @parser.parse(validations, description = true).should == ["h1", "div", "anything"]
+  end
+  it "raises exceptions for incorrect html element format" do
+    expect{ @parser.parse("1hi") }.to raise_error(Hercules::UptimeMonitor::ParserSyntaxError)
+    expect{ @parser.parse(" 1hi ") }.to raise_error(Hercules::UptimeMonitor::ParserSyntaxError)
+  end
+  it "returns the correct s expression for element validation" do
+    validations = <<-eos
+      div.where( class: "box_content")
+      div.where( id: "test", class: "test-section" )
+      link.where ( href: "https://www.southmunn.com/aboutus")
+      text_field.where(id: "search")
+    eos
+    @parser.parse(validations).should == [
+      [div: {class: "box_content"}],
+      [div: {id:"test", class: "test-section"}],
+      [link: {href: "https://www.southmunn.com/aboutus"}],
+      [text_field: {id: "search"}],
+    ]
+  end
+  it "returns the correct description for element validation" do
+    validations = <<-eos
+      div.where(class: "box_content")
+      div.where(id: "test", class: "test-section" )
+      link.where(href: "https://www.southmunn.com/aboutus")
+      text_field.where(id:"search")
+    eos
+    @parser.parse(validations, description = true).should == [
+      'div, with class="box_content"',
+      'div, with id="test", class="test-section"',
+      'link, with href="https://www.southmunn.com/aboutus"',
+      'text_field, with id="search"'
+    ]
+  end
+  it "returns the correct s expression for text validations" do
+    validations = <<-eos
+      title.with_text( "Welcome to my site" )
+      title.includes_text ( "Welcome")
+      div.where(class: "box_content").includes_text( "SouthMunn is a Website")
+      title.includes_text("ruby").includes_text ("Search Results")
+    eos
+    @parser.parse(validations).should == [
+      [:title, [text: "Welcome to my site"]],
+      [:title, [includes_text: "Welcome"]],
+      [{div: {class: "box_content"}}, [includes_text: "SouthMunn is a Website"]],
+      [:title, [includes_text: "ruby"], [includes_text: "Search Results"]]
+    ]
+  end
+  it "returns the correct description for text validations" do
+    validations = <<-eos
+      title.with_text("Welcome to my site")
+      title.includes_text("Welcome")
+      div.where(class: "box_content").includes_text("SouthMunn is a Website")
+      title.includes_text("ruby").includes_text("Search Results")
+    eos
+    @parser.parse(validations, description = true).should == [
+      'title, with text "Welcome to my site"',
+      'title, includes text "Welcome"',
+      'div, with class="box_content", includes text "SouthMunn is a Website"',
+      'title, includes text "ruby", includes text "Search Results"'
+    ]
+  end
+  it "returns the correct s expression for actions" do
+    validations = <<-eos
+      text_area.where(name:"longtext").set("In a world...")
+      select_list.where(name: "mydropdown").select("Old Cheese")
+      radio.where(name: "group1", value: "Milk").click
+      button.where(value: "Add to Cart").click
+      button.click
+    eos
+    @parser.parse(validations).should == [
+      [{text_area: {name: "longtext"}}, [set: "In a world..."]],
+      [{select_list: {name: "mydropdown"}},[select: "Old Cheese"]],
+      [{radio: {name: "group1", value: "Milk"}}, [:click]],
+      [{button: {value: "Add to Cart"}}, [:click]],
+      [:button, [:click]]
+    ]
+  end
+  it "returns the correct description for validations within actions" do
+    validations = <<-eos
+      text_area.where(name:"longtext").set("In a world...")
+      select_list.where(name: "mydropdown").select("Old Cheese")
+      radio.where(name: "group1", value: "Milk").click
+      button.where(value: "Add to Cart").click
+      button.click
+    eos
+    @parser.parse(validations, description = true).should == [
+      'text_area, with name="longtext"',
+      'select_list, with name="mydropdown"',
+      'radio, with name="group1", value="Milk"',
+      'button, with value="Add to Cart"',
+      'button'
+    ]
+  end
+  it "returns the correct s expression for waiting" do
+    validations = <<-eos
+      wait_for title.with_text("Obi Akubue")
+      wait_for title.includes_text("ruby").includes_text("Search Results")
+      wait_for text_field.where(id: "s").set("ruby")
+      wait_for div.where( class: "box_content")
+    eos
+    @parser.parse(validations).should == [
+      [wait_until_exists?: [:title,[text: "Obi Akubue"]]],
+      [wait_until_exists?: [:title, [includes_text: "ruby"], [includes_text: "Search Results"]]],
+      [wait_until_exists?: [{text_field: {id: "s"}}, [set: "ruby"]]],
+      [wait_until_exists?: [div: {class: "box_content"}]]
+    ]
+  end
+  it "returns the correct description for waiting" do
+    validations = <<-eos
+      wait_for title.with_text("Obi Akubue")
+      wait_for title.includes_text("ruby").includes_text("Search Results")
+      wait_for text_field.where(id: "s").set("ruby")
+      wait_for div.where( class: "box_content")
+    eos
+    @parser.parse(validations, description = true).should == [
+      'waited, title, with text "Obi Akubue"',
+      'waited, title, includes text "ruby", includes text "Search Results"',
+      'waited, text_field, with id="s"',
+      'waited, div, with class="box_content"'
+    ]
+  end
+  it "detects syntax errors" do
+    expect{ @parser.parse(".anything") }.to raise_error(Hercules::UptimeMonitor::ParserSyntaxError)
+    expect { @parser.parse("h1.where") }.to raise_error(Hercules::UptimeMonitor::ParserSyntaxError)
+    expect { @parser.parse("anything.anything") }.to raise_error(Hercules::UptimeMonitor::ParserSyntaxError)
+    expect { @parser.parse("div.where(\"test\" => \"test\")") }.to raise_error(Hercules::UptimeMonitor::ParserSyntaxError)
+    expect { @parser.parse("div.where(:test => \"test\")") }.to raise_error(Hercules::UptimeMonitor::ParserSyntaxError)
+    expect { @parser.parse("title.with_text(Welcome to my site\")") }.to raise_error(Hercules::UptimeMonitor::ParserSyntaxError)
+  end
+end
+
+

data/spec/uptime_monitor_spec.rb

@@ -33,73 +33,47 @@ describe Ragios::Plugin::UptimeMonitor do
     monitor = {browser: :browser, url: :url}
     expect{@uptime_monitor.init(monitor)}.to raise_error(Hercules::UptimeMonitor::NoValidationProvided)
   end
-  it "returns true if page element exists" do
-    monitor = {browser: :browser, exists?: :exists, url: :url}
-    @uptime_monitor.init(monitor)
-    @uptime_monitor.start_browser("http://obi-akubue.org","firefox", headless = true)
-    page_element = [:title]
-    @uptime_monitor.exists([page_element])
-    @uptime_monitor.test_result.should == {:results => [[page_element, "exists_as_expected"]]}
-    @uptime_monitor.has_screenshot.should == nil #since no test_command? was run
-    @uptime_monitor.screenshot_url.should == nil
-    @uptime_monitor.success.should == nil #since no test_command? was run
-    @uptime_monitor.close_browser
-  end
-  it "returns false if page element don't exists" do
-    monitor = {browser: :browser, exists?: :exists, url: :url}
-    @uptime_monitor.init(monitor)
-    @uptime_monitor.start_browser("http://obi-akubue.org","firefox", headless = true)
-    page_element = [:title, [text: "dont_exist"]]
-    @uptime_monitor.exists([page_element])
-    @uptime_monitor.test_result.should == {:results => [[page_element, "does_not_exist_as_expected"]]}
-    if @uptime_monitor.has_screenshot
-      !!(/^.*\.png$/.match(@uptime_monitor.screenshot_url)).should == true
-    end
-    @uptime_monitor.success.should == false
-    @uptime_monitor.close_browser
-  end
   it "runs a test that passes" do
-    page_element = [:title]
-    monitor = {url: "http://obi-akubue.org",
-                browser: ["firefox", headless: true],
-                exists?: [page_element]
-              }
+    monitor = {
+      url: "http://obi-akubue.org",
+      browser: "firefox headless",
+      exists?: "title"
+    }
     @uptime_monitor.init(monitor)
     @uptime_monitor.test_command?.should == true
-    @uptime_monitor.test_result.should == {:results => [[page_element, "exists_as_expected"]]}
+    @uptime_monitor.test_result.should == {:results => [["title", "exists_as_expected"]]}
     @uptime_monitor.has_screenshot.should == false
     @uptime_monitor.screenshot_url.should == nil
-    @uptime_monitor.success.should == true 
+    @uptime_monitor.success.should == true
     @uptime_monitor.close_browser
   end
   it "runs a test that fails" do
-    page_element = [:title, [text: "dont_exist"]]
-    monitor = {url: "http://obi-akubue.org",
-                browser: ["firefox", headless: true],
-                exists?: [page_element]
-              }
+    monitor = {
+      url: "http://obi-akubue.org",
+      browser: "firefox headless",
+      exists?: 'title.with_text("dont_exist")'
+    }
     @uptime_monitor.init(monitor)
     @uptime_monitor.test_command?.should == false
-    @uptime_monitor.test_result.should  include(:results => [[page_element, "does_not_exist_as_expected"]])
+    @uptime_monitor.test_result.first.should  == [:results, [["title, with text \"dont_exist\"", "does_not_exist_as_expected"]]]
     if @uptime_monitor.has_screenshot
       !!(/^.*\.png$/.match(@uptime_monitor.screenshot_url)).should == true
     end
-    @uptime_monitor.success.should == false     
+    @uptime_monitor.success.should == false
     @uptime_monitor.close_browser
   end
-  it "can disable screenshot capture when a test fails for individual monitors" do 
-    page_element = [:title, [text: "dont_exist"]]
+  it "can disable screenshot capture when a test fails for individual monitors" do
     monitor = {
       url: "http://obi-akubue.org",
-      browser: ["firefox", headless: true],
-      exists?: [page_element],
+      browser: "firefox headless",
+      exists?: 'title.with_text("dont_exist")',
       disable_screenshots: true
     }
     @uptime_monitor.init(monitor)
     @uptime_monitor.test_command?.should == false
     @uptime_monitor.has_screenshot.should == false
     @uptime_monitor.screenshot_url.should == nil
-    @uptime_monitor.success.should == false 
+    @uptime_monitor.success.should == false
     @uptime_monitor.close_browser
   end
 end