spec/unit/matcher/scanner_spec.rb

   1 #! /usr/bin/env rspec
   2
   3 require 'spec_helper'
   4
   5 module MCollective
   6   module Matcher
   7     describe 'scanner' do
   8       it "should identify a '(' token" do
   9         scanner = Scanner.new("(")
  10         token = scanner.get_token
  11         token.should == ["(", "("]
  12       end
  13
  14       it "should identify a ')' token" do
  15         scanner = Scanner.new(")")
  16         token = scanner.get_token
  17         token.should == [")", ")"]
  18       end
  19
  20       it "should identify a 'and' token" do
  21         scanner = Scanner.new("and ")
  22         token = scanner.get_token
  23         token.should == ["and", "and"]
  24       end
  25
  26       it "should identify a 'or' token" do
  27         scanner = Scanner.new("or ")
  28         token = scanner.get_token
  29         token.should == ["or", "or"]
  30       end
  31
  32       it "should identify a 'not' token" do
  33         scanner = Scanner.new("not ")
  34         token = scanner.get_token
  35         token.should == ["not", "not"]
  36       end
  37
  38       it "should identify a '!' token" do
  39         scanner = Scanner.new("!")
  40         token = scanner.get_token
  41         token.should == ["not", "not"]
  42       end
  43
  44       it "should identify a fact statement token" do
  45         scanner = Scanner.new("foo=bar")
  46         token = scanner.get_token
  47         token.should == ["statement", "foo=bar"]
  48       end
  49
  50       it "should identify a fact statement token" do
  51         scanner = Scanner.new("foo=bar")
  52         token = scanner.get_token
  53         token.should == ["statement", "foo=bar"]
  54       end
  55
  56       it "should identify a class statement token" do
  57         scanner = Scanner.new("/class/")
  58         token = scanner.get_token
  59         token.should == ["statement", "/class/"]
  60       end
  61
  62       it "should identify a function statement token with a dot value" do
  63         scanner = Scanner.new("foo('bar').baz")
  64         token = scanner.get_token
  65         token.should == ["fstatement", "foo('bar').baz"]
  66       end
  67
  68       it "should identify a function statement token without a dot value" do
  69         scanner = Scanner.new("foo('bar')")
  70         token = scanner.get_token
  71         token.should == ["fstatement", "foo('bar')"]
  72       end
  73
  74       it "should identify a function statement with multiple parameters" do
  75         scanner = Scanner.new("foo('bar','baz')")
  76         token = scanner.get_token
  77         token.should == ["fstatement", "foo('bar','baz')"]
  78       end
  79
  80       it "should identify a bad token when a function is missing its end bracket" do
  81         scanner = Scanner.new("foo(")
  82         token = scanner.get_token
  83         token.should == ["bad_token", [0,3]]
  84       end
  85
  86       it "should identify a bad token when there is a regex before a comparison operator" do
  87         scanner = Scanner.new("/foo/=bar")
  88         token = scanner.get_token
  89         token.should == ["bad_token", [0,8]]
  90       end
  91
  92       it "should identify a bad token where there is a forward slash before a comparison operator" do
  93         scanner = Scanner.new("/foo=bar")
  94         token = scanner.get_token
  95         token.should == ["bad_token", [0,7]]
  96       end
  97
  98       it "should identify a bad token where there is only one forward slash after a comparison operator" do
  99         scanner = Scanner.new("foo=/bar")
 100         token = scanner.get_token
 101         token.should == ["bad_token", [0,7]]
 102       end
 103
 104       it "should identify a bad token where function parameters are not in single quotes" do
 105         scanner = Scanner.new("foo(bar)")
 106         token = scanner.get_token
 107         token.should == ["bad_token", [0,7]]
 108       end
 109
 110       it "should identify a bad token where there are non alphanumerical or underscore chars in the dot value" do
 111         scanner = Scanner.new("foo('bar').val-ue")
 112         token = scanner.get_token
 113         token.should == ["bad_token", [0,16]]
 114       end
 115
 116       it "should identify a bad token where there are chained dot values" do
 117         scanner = Scanner.new("foo('bar').a.b")
 118         token = scanner.get_token
 119         token.should == ["bad_token", [0,13]]
 120       end
 121
 122       it "should identify bad tokens where function parameters are not comma seperated" do
 123         scanner = Scanner.new("foo('a' 'b')")
 124         token = scanner.get_token
 125         token.should == ["bad_token", [0,11]]
 126
 127         scanner = Scanner.new("foo(\"a\" \"b\")")
 128         token = scanner.get_token
 129         token.should == ["bad_token", [0,11]]
 130
 131       end
 132
 133       it "should identify fstatement tokens where the values and the comparison operator are seperated by whitespaces" do
 134         scanner = Scanner.new("foo('a').bar  = 1")
 135         token = scanner.get_token
 136         token.should == ["fstatement", "foo('a').bar=1"]
 137       end
 138
 139       it "should identify statement tokens where the values and the comparison operator are seperated by whitespaces" do
 140         scanner = Scanner.new("a =  c")
 141         token = scanner.get_token
 142         token.should == ["statement", "a=c"]
 143       end
 144
 145       it "should idenify a function statement where a parameter is an empty string" do
 146         scanner = Scanner.new("foo('')")
 147         token = scanner.get_token
 148         token.should == ["fstatement", "foo('')"]
 149       end
 150
 151       it "should correctly tokenize a statement with escaped qoutes in parameters" do
 152         scanner = Scanner.new("foo('\"bar\"')")
 153         token = scanner.get_token
 154         token.should == ["fstatement", "foo('\"bar\"')"]
 155
 156         scanner = Scanner.new('foo("\'bar\'")')
 157         token =scanner.get_token
 158         token.should == ["fstatement", "foo(\"'bar'\")"]
 159       end
 160
 161       it "should correctly tokenize a statement where a regular expression contains parentheses" do
 162         scanner = Scanner.new("foo=/bar(1|2)/")
 163         token = scanner.get_token
 164         token.should == ["statement", "foo=/bar(1|2)/"]
 165       end
 166
 167       it "should correctly tokenize a statement with a comparison operator in a parameter" do
 168         scanner = Scanner.new("foo('bar=baz')")
 169         token = scanner.get_token
 170         token.should == ["fstatement", "foo('bar=baz')"]
 171       end
 172     end
 173   end
 174 end