wagn 1.12.7

data/spec/lib/card/name_spec.rb

@@ -0,0 +1,275 @@
+# -*- encoding : utf-8 -*-
+  # encoding: utf-8
+require 'wagn/spec_helper'
+
+describe Card::Name do
+
+  describe "#key" do
+    
+    it "should lowercase and underscore" do
+      "This Name".to_name.key.should == "this_name"
+    end
+    
+    it "should remove spaces" do
+      "this    Name".to_name.key.should == "this_name"
+    end
+
+    describe "underscores" do
+      
+      it "should be treated like spaces" do
+        'weird_ combo'.to_name.key.should == 'weird  combo'.to_name.key
+      end
+      
+      it "should not impede pluralization checks" do
+        'Mamas_and_Papas'.to_name.key.should == "Mamas and Papas".to_name.key
+      end
+      
+      it "should be removed when before first word character" do
+        "_This Name".to_name.key.should == "this_name"
+      end
+      
+    end
+
+    it "should singularize" do
+      "ethans".to_name.key.should == "ethan"
+    end
+
+    it "should change CamelCase to snake case" do
+      "ThisThing".to_name.key.should == "this_thing"
+    end
+
+    it "should handle plus cards" do
+      "ThisThing+Ethans".to_name.key.should == "this_thing+ethan"
+    end
+
+    it "should retain * for star cards" do
+      "*right".to_name.key.should == "*right"
+    end
+
+    it "should not singularize double s's" do
+      "grass".to_name.key.should == 'grass'
+    end
+
+    it "should not singularize letter 'S'" do
+      'S'.to_name.key.should == 's'
+    end
+
+    it "should handle unicode characters" do
+      "Mañana".to_name.key.should == 'mañana'
+    end
+
+    it "should handle weird initial characters" do
+      '__you motha @#$'.to_name.key.should == 'you_motha'
+      '?!_you motha @#$'.to_name.key.should == 'you_motha'
+    end
+
+    it "should allow numbers" do
+      "3way".to_name.key.should == '3way'
+    end
+
+    it "internal plurals" do
+      "cards hooks label foos".to_name.key.should == 'card_hook_label_foo'
+    end
+
+    it "should handle html entities" do
+      # This no longer takes off the s, is singularize broken now?
+      "Jean-françois Noubel".to_name.key.should == 'jean_françoi_noubel'
+    end
+  end
+
+
+
+
+
+  describe "#url_key" do
+    cardnames = ["GrassCommons.org", 'Oh you @##', "Alice's Restaurant!", "PB & J", "Mañana"].map(&:to_name)
+
+    cardnames.each do |cardname|
+      it "should have the same key as the name" do
+        k, k2 = cardname.key, cardname.url_key
+        #warn "cn tok #{cardname.inspect}, #{k.inspect}, #{k2.inspect}"
+        k.should == k2.to_name.key
+      end
+    end
+  end
+
+  describe "#valid" do
+    it "accepts valid names" do
+      "this+THAT".to_name.should be_valid
+      "THE*ONE*AND$!ONLY".to_name.should be_valid
+    end
+
+    it "rejects invalid names" do
+#      "Tes~sd".to_name.should_not be_valid
+      "TEST/DDER".to_name.should_not be_valid
+    end
+  end
+
+  describe "#left_name" do
+    it "returns nil for non junction" do
+      "a".to_name.left_name.should == nil
+    end
+
+    it "returns parent for parent" do
+      "a+b+c+d".to_name.left_name.should == "a+b+c"
+    end
+  end
+
+  describe "#tag_name" do
+    it "returns last part of plus card" do
+      "a+b+c".to_name.tag.should == "c"
+    end
+
+    it "returns name of simple card" do
+      "a".to_name.tag.should == "a"
+    end
+  end
+
+  describe "#safe_key" do
+    it "subs pluses & stars" do
+      "Alpha?+*be-ta".to_name.safe_key.should == "alpha-Xbe_tum"
+    end
+  end
+
+  describe "#replace_part" do
+    it "replaces first name part" do
+      'a+b'.to_name.replace_part('a','x').to_s.should == 'x+b'
+    end
+    it "replaces second name part" do
+      'a+b'.to_name.replace_part('b','x').to_s.should == 'a+x'
+    end
+    it "replaces two name parts" do
+      'a+b+c'  .to_name.replace_part('a+b', 'x'  ).to_s.should == 'x+c'
+      'a+b+c+d'.to_name.replace_part('a+b', 'e+f').to_s.should == 'e+f+c+d'
+    end
+    it "doesn't replace two part tag" do
+      'a+b+c'.to_name.replace_part('b+c','x').to_s.should == 'a+b+c'
+    end
+  end
+
+  describe "Cardnames star handling" do
+    it "recognizes star cards" do
+      '*a'.to_name.star?.should be_true
+    end
+
+    it "doesn't recognize star cards with plusses" do
+      '*a+*b'.to_name.star?.should be_false
+    end
+
+    it "recognizes rstar cards" do
+      'a+*a'.to_name.rstar?.should be_true
+    end
+
+    it "doesn't recognize star cards as rstar" do
+      '*a'.to_name.rstar?.should be_false
+    end
+
+    it "doesn't recognize non-star or star left" do
+      '*a+a'.to_name.rstar?.should be_false
+    end
+  end
+
+  describe "trait_name?" do
+    it "returns true for content codename" do
+      "bazoinga+*right+*structure".to_name.trait_name?(:structure).should be_true
+    end
+
+    it "handles arrays" do
+      "bazoinga+*right+*structure".to_name.trait_name?(:structure, :default).should be_true
+    end
+
+    it "returns false for non-template" do
+      "bazoinga+*right+nontent".to_name.trait_name?(:structure).should be_false
+    end
+  end
+
+  describe "#to_absolute" do
+    it "handles _self, _whole, _" do
+      "_self".to_name.to_absolute("foo").should == "foo"
+      "_whole".to_name.to_absolute("foo").should == "foo"
+      "_".to_name.to_absolute("foo").should == "foo"
+    end
+
+    it "handles _left" do
+      "_left+Z".to_name.to_absolute("A+B+C").should == "A+B+Z"
+    end
+
+    it "handles white space" do
+      "_left + Z".to_name.to_absolute("A+B+C").should == "A+B+Z"
+    end
+
+    it "handles _right" do
+      "_right+bang".to_name.to_absolute("nutter+butter").should == "butter+bang"
+      "C+_right".to_name.to_absolute("B+A").should == "C+A"
+    end
+
+    it "handles leading +" do
+      "+bug".to_name.to_absolute("hum").should == "hum+bug"
+    end
+
+    it "handles trailing +" do
+      "bug+".to_name.to_absolute("tracks").should == "bug+tracks"
+    end
+
+    it "handles _(numbers)" do
+      "_1".to_name.to_absolute("A+B+C").should == "A"
+      "_1+_2".to_name.to_absolute("A+B+C").should == "A+B"
+      "_2+_3".to_name.to_absolute("A+B+C").should == "B+C"
+    end
+
+    it "handles _LLR etc" do
+      "_R".to_name.to_absolute("A+B+C+D+E").should    == "E"
+      "_L".to_name.to_absolute("A+B+C+D+E").should    == "A+B+C+D"
+      "_LR".to_name.to_absolute("A+B+C+D+E").should   == "D"
+      "_LL".to_name.to_absolute("A+B+C+D+E").should   == "A+B+C"
+      "_LLR".to_name.to_absolute("A+B+C+D+E").should  == "C"
+      "_LLL".to_name.to_absolute("A+B+C+D+E").should  == "A+B"
+      "_LLLR".to_name.to_absolute("A+B+C+D+E").should == "B"
+      "_LLLL".to_name.to_absolute("A+B+C+D+E").should == "A"
+    end
+
+    context "mismatched requests" do
+      it "returns _self for _left or _right on simple cards" do
+        "_left+Z".to_name.to_absolute("A").should == "A+Z"
+        "_right+Z".to_name.to_absolute("A").should == "A+Z"
+      end
+
+      it "handles bogus numbers" do
+        "_1".to_name.to_absolute("A").should == "A"
+        "_1+_2".to_name.to_absolute("A").should == "A+A"
+        "_2+_3".to_name.to_absolute("A").should == "A+A"
+      end
+
+      it "handles bogus _llr requests" do
+           "_R".to_name.to_absolute("A").should == "A"
+           "_L".to_name.to_absolute("A").should == "A"
+          "_LR".to_name.to_absolute("A").should == "A"
+          "_LL".to_name.to_absolute("A").should == "A"
+         "_LLR".to_name.to_absolute("A").should == "A"
+         "_LLL".to_name.to_absolute("A").should == "A"
+        "_LLLR".to_name.to_absolute("A").should == "A"
+        "_LLLL".to_name.to_absolute("A").should == "A"
+      end
+    end
+
+    it "does session user substitution" do
+      "_user".to_name.to_absolute("A").should == Account.current.name
+      Account.as_bot do
+        "_user".to_name.to_absolute("A").should == Account.current.name
+      end
+    end
+  end
+
+  describe "#to_show" do
+    it "ignores ignorables" do
+         'you+awe'.to_name.to_show('you').should == '+awe'
+      'me+you+awe'.to_name.to_show('you').should == 'me+awe' #HMMM..... what should this do?
+      'me+you+awe'.to_name.to_show('me' ).should == '+you+awe'
+      'me+you+awe'.to_name.to_show('me','you').should == '+awe'
+          'me+you'.to_name.to_show('me','you').should == 'me+you'
+         '?a?+awe'.to_name.to_show('A').should == '+awe'
+            '+awe'.to_name.to_show().should == '+awe'
+    end
+  end
+
+end

data/spec/lib/card/query_spec.rb

@@ -0,0 +1,456 @@
+# -*- encoding : utf-8 -*-
+require 'wagn/spec_helper'
+
+A_JOINEES = ["B", "C", "D", "E", "F"]
+
+CARDS_MATCHING_TWO = ["Two","One+Two","One+Two+Three","Joe User"].sort
+
+describe Card::Query do
+
+  describe 'append' do
+    it "should find real cards" do
+      Card::Query.new(:name=>[:in, 'C', 'D', 'F'], :append=>'A' ).run.map(&:name).sort.should == ["C+A", "D+A", "F+A"]
+    end
+
+    it "should absolutize names" do
+      Card::Query.new(:name=>[:in, 'C', 'D', 'F'], :append=>'_right', :context=>'B+A' ).run.map(&:name).sort.should == ["C+A", "D+A", "F+A"]
+    end
+
+    it "should find virtual cards" do
+      Card::Query.new(:name=>[:in, 'C', 'D'], :append=>'*plus cards' ).run.map(&:name).sort.should == ["C+*plus cards", "D+*plus cards"]
+    end
+  end
+
+  describe "in" do
+    it "should work for content options" do
+      Card::Query.new(:in=>['AlphaBeta', 'Theta']).run.map(&:name).sort.should == %w(A+B T)
+    end
+
+    it "should find the same thing in full syntax" do
+      Card::Query.new(:content=>[:in,'Theta','AlphaBeta']).run.map(&:name).sort.should == %w(A+B T)
+    end
+
+    it "should work on types" do
+      Card::Query.new(:type=>[:in,'Cardtype E', 'Cardtype F']).run.map(&:name).sort.should == %w(type-e-card type-f-card)
+    end
+  end
+
+  describe "symbolization" do
+    it "should handle array values" do
+      query = {'plus'=>['tags',{'refer_to'=>'cookies'}]}
+      Card::Query.new(query).query.should== {:plus=>['tags',{:refer_to=>'cookies'}]}
+    end
+  end
+
+
+
+
+
+  describe "member_of/member" do
+    it "member_of should find members" do
+      Card::Query.new( :member_of => "r1" ).run.map(&:name).sort.should == %w(u1 u2 u3)
+    end
+    it "member should find roles" do
+      Card::Query.new( :member => {:match=>"u1"} ).run.map(&:name).sort.should == %w(r1 r2 r3)
+    end
+  end
+
+
+  describe "not" do
+    it "should exclude cards matching not criteria" do
+      Card::Query.new(:plus=>"A", :not=>{:plus=>"A+B"}).run.map(&:name).sort.should==%w{ B D E F }
+    end
+  end
+  
+  
+  describe "multiple values" do
+    it "should handle multiple values for relational keys" do
+      Card::Query.new( :member_of=>[:all, {:name=>'r1'}, {:key=>'r2'} ], :return=>:name).run.sort.should == %w{ u1 u2 }
+      Card::Query.new( :member_of=>[      {:name=>'r1'}, {:key=>'r2'} ], :return=>:name).run.sort.should == %w{ u1 u2 }
+      Card::Query.new( :member_of=>[:any, {:name=>'r1'}, {:key=>'r2'} ], :return=>:name).run.sort.should == %w{ u1 u2 u3 }      
+    end
+    
+    it "should handle multiple values for plus_relational keys" do
+      Card::Query.new( :right_plus=>[ :all, 'e', 'c' ], :return=>:name ).run.sort.should == %w{ A } #explicit conjunction
+      Card::Query.new( :right_plus=>[ ['e',{}],  'c' ], :return=>:name ).run.sort.should == %w{ A } # first element is array
+      Card::Query.new( :right_plus=>[ 'e', 'c'       ], :return=>:name ).run.sort.should == []      # NOT interpreted as multi-value
+    end
+
+    it "should handle multiple values for plus_relational keys" do
+      Card::Query.new( :refer_to=>[ :and, 'a', 'b' ], :return=>:name ).run.sort.should == %w{ Y } 
+      Card::Query.new( :refer_to=>[       'a', 'T' ], :return=>:name ).run.sort.should == %w{ X Y }
+      Card::Query.new( :refer_to=>[ :or,  'b', 'z' ], :return=>:name ).run.sort.should == %w{ A B Y}
+    end
+        
+  end
+
+
+  describe "edited_by/editor_of" do
+    it "should find card edited by joe using subspec" do
+      Card::Query.new(:edited_by=>{:match=>"Joe User"}, :sort=>"name").run.should == [Card["JoeLater"], Card["JoeNow"]]
+    end
+    it "should find card edited by Wagn Bot" do
+      #this is a weak test, since it gives the name, but different sorting mechanisms in other db setups
+      #was having it return *account in some cases and "A" in others
+      Card::Query.new(:edited_by=>"Wagn Bot", :name=>'A', :return=>'name', :limit=>1).run.first.should == "A"
+    end
+    it "should fail gracefully if user isn't there" do
+      Card::Query.new(:edited_by=>"Joe LUser", :sort=>"name", :limit=>1).run.should == []
+    end
+
+    it "should not give duplicate results for multiple edits" do
+      c=Card["JoeNow"]
+      c.content="testagagin"
+      c.save
+      c.content="test3"
+      c.save!
+      Card::Query.new(:edited_by=>"Joe User").run.map(&:name).sort.should == ["JoeLater","JoeNow"]
+    end
+
+    it "should find joe user among card's editors" do
+      Card::Query.new(:editor_of=>'JoeLater').run.map(&:name).should == ['Joe User']
+    end
+  end
+
+  describe "created_by/creator_of" do
+    before do
+      Card.create :name=>'Create Test', :content=>'sufficiently distinctive'
+    end
+
+    it "should find Joe User as the card's creator" do
+      c = Card.fetch 'Create Test'
+      Card::Query.new(:creator_of=>'Create Test').run.first.name.should == 'Joe User'
+    end
+
+    it "should find card created by Joe User" do
+      Card::Query.new(:created_by=>'Joe User', :eq=>'sufficiently distinctive').run.first.name.should == 'Create Test'
+    end
+  end
+
+  describe "last_edited_by/last_editor_of" do
+    before do
+      c=Card.fetch('A')
+      c.content='peculicious'
+      c.save!
+    end
+
+    it "should find Joe User as the card's last editor" do
+      Card::Query.new(:last_editor_of=>'A').run.first.name.should == 'Joe User'
+    end
+
+    it "should find card created by Joe User" do
+      Card::Query.new(:last_edited_by=>'Joe User', :eq=>'peculicious').run.first.name.should == 'A'
+    end
+  end
+
+  describe "keyword" do
+    it "should escape nonword characters" do
+      Card::Query.new( :match=>"two :(!").run.map(&:name).sort.should==CARDS_MATCHING_TWO
+    end
+  end
+
+  describe "search count" do
+    it "should count search" do
+      s = Card.create! :name=>"ksearch", :type=>'Search', :content=>'{"match":"$keyword"}'
+      s.count(:vars=>{:keyword=>"two"}).should==CARDS_MATCHING_TWO.length
+    end
+  end
+
+
+  describe "cgi_params" do
+    it "should match content from cgi" do
+      Card::Query.new( :match=>"$keyword", :vars=>{:keyword=>"two"}).run.map(&:name).sort.should==CARDS_MATCHING_TWO
+    end
+  end
+
+
+
+  describe "content equality" do
+    it "should match content explicitly" do
+      Card::Query.new( :content=>['=',"I'm number two"] ).run.map(&:name).should==["Joe User"]
+    end
+    it "should match via shortcut" do
+      Card::Query.new( '='=>"I'm number two" ).run.map(&:name).should==["Joe User"]
+    end
+  end
+
+
+  describe "links" do
+
+    it("should handle refer_to")      { Card::Query.new( :refer_to=>'Z').run.map(&:name).sort.should == %w{ A B } }
+    it("should handle link_to")       { Card::Query.new( :link_to=>'Z').run.map(&:name).should == %w{ A } }
+    it("should handle include" )      { Card::Query.new( :include=>'Z').run.map(&:name).should == %w{ B } }
+    it("should handle linked_to_by")   { Card::Query.new( :linked_to_by=>'A').run.map(&:name).should == %w{ Z } }
+    it("should handle included_by")    { Card::Query.new( :included_by=>'B').run.map(&:name).should == %w{ Z } }
+    it("should handle referred_to_by") { Card::Query.new( :referred_to_by=>'X').run.map(&:name).sort.should == %w{ A A+B T } }
+  end
+
+  describe "relative links" do
+    it("should handle relative refer_to")  { Card::Query.new( :refer_to=>'_self', :context=>'Z').run.map(&:name).sort.should == %w{ A B } }
+  end
+
+  describe "permissions" do
+    it "should not find cards not in group" do
+      Account.as_bot  do
+        Card.create :name=>"C+*self+*read", :type=>'Pointer', :content=>"[[R1]]"
+      end
+      Card::Query.new( :plus=>"A" ).run.map(&:name).sort.should == %w{ B D E F }
+    end
+  end
+
+  describe "basics" do
+    it "should be case insensitive for name" do
+      Card::Query.new( :name=>"a" ).run.first.name.should == 'A'
+    end
+
+    it "should find plus cards" do
+      Card::Query.new( :plus=>"A" ).run.map(&:name).sort.should == A_JOINEES
+    end
+
+    it "should find connection cards" do
+      Card::Query.new( :part=>"A" ).run.map(&:name).sort.should == ["A+B", "A+C", "A+D", "A+E", "C+A", "D+A", "F+A"]
+    end
+
+    it "should find left connection cards" do
+      Card::Query.new( :left=>"A" ).run.map(&:name).sort.should == ["A+B", "A+C", "A+D", "A+E"]
+    end
+
+    it "should find right connection cards" do
+      Card::Query.new( :right=>"A" ).run.map(&:name).sort.should == ["C+A", "D+A", "F+A"]
+    end
+
+    it "should return count" do
+      Card.count_by_wql( :part=>"A" ).should == 7
+    end
+
+
+  end
+
+  describe "limit and offset" do
+    it "should return limit" do
+      Card::Query.new( :part=>"A", :limit=>5 ).run.size.should == 5
+    end
+
+    it "should not break if offset but no limit" do
+      Card::Query.new( :part=>"A", :offset=>5 ).run.size.should_not == 0
+    end
+
+  end
+
+  describe "type" do
+    user_cards =  ["Joe Admin", "Joe Camel", "Joe User", "John", "No Count", "Sample User", "Sara", "u1", "u2", "u3"].sort
+
+    it "should find cards of this type" do
+      Card::Query.new( :type=>"_self", :context=>'User').run.map(&:name).sort.should == user_cards
+    end
+
+    it "should find User cards " do
+      Card::Query.new( :type=>"User" ).run.map(&:name).sort.should == user_cards
+    end
+
+    it "should handle casespace variants" do
+      Card::Query.new( :type=>"users" ).run.map(&:name).sort.should == user_cards
+    end
+
+  end
+
+
+  describe "trash handling" do
+    it "should not find cards in the trash" do
+      Card["A+B"].delete!
+      Card::Query.new( :left=>"A" ).run.map(&:name).sort.should == ["A+C", "A+D", "A+E"]
+    end
+  end
+
+
+
+
+  describe "order" do
+    it "should sort by create" do
+      Card.create! :type=>"Cardtype", :name=>"Nudetype"
+      Card.create! :type=>"Nudetype", :name=>"nfirst", :content=>"a"
+      Card.create! :type=>"Nudetype", :name=>"nsecond", :content=>"b"
+      Card.create! :type=>"Nudetype", :name=>"nthird", :content=>"c"
+      # WACK!! this doesn't seem to be consistent across fixture generations :-/
+      Card::Query.new( :type=>"Nudetype", :sort=>"create", :dir=>"asc").run.map(&:name).should ==
+        ["nfirst","nsecond","nthird"]
+    end
+
+    it "should sort by name" do
+      Card::Query.new( :name=> %w{ in B Z A Y C X }, :sort=>"alpha", :dir=>"desc" ).run.map(&:name).should ==  %w{ Z Y X C B A }
+      Card::Query.new( :name=> %w{ in B Z A Y C X }, :sort=>"name", :dir=>"desc"  ).run.map(&:name).should ==  %w{ Z Y X C B A }
+      #Card.create! :name => 'the alphabet'
+      #Card::Query.new( :name=>["in", "B", "C", "the alphabet"], :sort=>"name").run.map(&:name).should ==  ["the alphabet", "B", "C"]
+    end
+
+    it "should sort by content" do
+      Card::Query.new( :name=> %w{ in Z T A }, :sort=>"content").run.map(&:name).should ==  %w{ A Z T }
+    end
+
+    it "should play nice with match" do
+      Card::Query.new( :match=>'Z', :type=>'Basic', :sort=>"content").run.map(&:name).should ==  %w{ A B Z }
+    end
+
+    it "should sort by plus card content" do
+      Account.as_bot do
+        c = Card.fetch('Setting+*self+*table of contents')
+        c.content = '10'
+        c.save
+        c = Card['Basic+*type+*table of contents']
+        c.content = '3'
+        c.save
+
+        w = Card::Query.new( :right_plus=>'*table of contents', :sort=>{ :right=>'*table_of_contents'}, :sort_as=>'integer'  ) # FIXME: codename
+        #warn "sql from new wql = #{w.sql}"
+        w.run.map(&:name).should == %w{ *all *account+*right Basic+*type Config+*self Setting+*self }
+      end
+    end
+
+    it "should sort by count" do
+      Account.as_bot do
+        w = Card::Query.new( :name=>[:in,'Sara','John','Joe User'], :sort=>{ :right=>'*watcher', :item=>'referred_to', :return=>'count' } )
+        w.run.map(&:name).should == ['Joe User','John','Sara']
+      end
+    end
+
+  #  it "should sort by update" do
+  #    # do this on a restricted set so it won't change every time we add a card..
+  #    Card::Query.new( :match=>"two", :sort=>"update", :dir=>"desc").run.map(&:name).should == ["One+Two+Three", "One+Two","Two","Joe User"]
+  #    Card["Two"].update_attributes! :content=>"new bar"
+  #    Card::Query.new( :match=>"two", :sort=>"update", :dir=>"desc").run.map(&:name).should == ["Two","One+Two+Three", "One+Two","Joe User"]
+  #  end
+  #
+
+  end
+
+  describe "params" do
+    it "should merge in params as normal WQL" do
+      Card::Query.new( :params=>{:name=>"two"}).run.first.name.should=='Two'
+    end
+  end
+
+
+  describe "match" do
+    it "should reach content and name via shortcut" do
+      Card::Query.new( :match=>"two").run.map(&:name).sort.should==CARDS_MATCHING_TWO
+    end
+
+    it "should get only content when content is explicit" do
+      Card::Query.new( :content=>[:match, "two"] ).run.map(&:name).sort.should==["Joe User"]
+    end
+
+    it "should get only name when name is explicit" do
+      Card::Query.new( :name=>[:match, "two"] ).run.map(&:name).sort.should==["One+Two","One+Two+Three","Two"].sort
+    end
+  end
+
+  describe "and" do
+    it "should act as a simple passthrough" do
+      Card::Query.new(:and=>{:match=>'two'}).run.map(&:name).sort.should==CARDS_MATCHING_TWO
+    end
+
+    it "should work within 'or'" do
+      results = Card::Query.new(:or=>{:name=>'Z', :and=>{:left=>'A', :right=>'C'}}).run
+      results.length.should == 2
+      results.map(&:name).sort.should == ['A+C','Z']
+    end
+  end
+
+  describe "or" do
+    it "should work with :plus" do
+      Card::Query.new(:plus=>"A", :or=>{:name=>'B', :match=>'K'}).run.map(&:name).sort.should==%w{ B }
+    end
+  end
+
+  describe "offset" do
+    it "should not break count" do
+      Card.count_by_wql({:match=>'two', :offset=>1}).should==CARDS_MATCHING_TWO.length
+    end
+  end
+
+
+  #=end
+  describe "found_by" do
+    before do
+      Account.current_id = Card::WagnBotID
+      c = Card.create(:name=>'Simple Search', :type=>'Search', :content=>'{"name":"A"}')
+    end
+
+    it "should find cards returned by search of given name" do
+      Card::Query.new(:found_by=>'Simple Search').run.first.name.should=='A'
+    end
+    it "should find cards returned by virtual cards" do
+      Card::Query.new(:found_by=>'Image+*type+by name').run.map(&:name).sort.should==Card.search(:type=>'Image').map(&:name).sort
+    end
+    it "should play nicely with other properties and relationships" do
+      Card::Query.new(:plus=>{:found_by=>'Simple Search'}).run.map(&:name).sort.should==Card::Query.new(:plus=>{:name=>'A'}).run.map(&:name).sort
+    end
+    it "should be able to handle _self" do
+      Card::Query.new(:context=>'Simple Search', :left=>{:found_by=>'_self'}, :right=>'B').run.first.name.should=='A+B'
+    end
+
+  end
+
+
+
+  #=end
+
+  describe "relative" do
+    it "should clean wql" do
+      wql = Card::Query.new( :part=>"_self",:context=>'A' )
+      wql.query[:part].should == 'A'
+    end
+
+    it "should find connection cards" do
+      Card::Query.new( :part=>"_self", :context=>'A' ).run.map(&:name).sort.should == ["A+B", "A+C", "A+D", "A+E", "C+A", "D+A", "F+A"]
+    end
+
+    it "should be able to use parts of nonexistent cards in search" do
+      Card['B+A'].should be_nil
+      Card::Query.new( :left=>'_right', :right=>'_left', :context=>'B+A' ).run.map(&:name).should == ['A+B']
+    end
+
+    it "should find plus cards for _self" do
+      Card::Query.new( :plus=>"_self", :context=>"A" ).run.map(&:name).sort.should == A_JOINEES
+    end
+
+    it "should find plus cards for _left" do
+      Card::Query.new( :plus=>"_left", :context=>"A+B" ).run.map(&:name).sort.should == A_JOINEES
+    end
+
+    it "should find plus cards for _right" do
+      Card::Query.new( :plus=>"_right", :context=>"C+A" ).run.map(&:name).sort.should == A_JOINEES
+    end
+
+  end
+
+
+  describe "nested permissions" do
+    it "are generated by default" do
+      perm_count = 0
+      Card::Query.new( { :left=>{:name=>"X"}}).sql.scan( /read_rule_id IN \([\d\,]+\)/ ) do |m|
+        perm_count+=1
+      end
+      perm_count.should == 2
+    end
+
+#    it "are not generated inside .without_nested_permissions block" do
+#      perm_count = 0
+#      Card::Query.without_nested_permissions do
+#        Card::Query.new( { :left=>{:name=>"X"}}).sql.scan( /read_rule_id IN \([\d\,]+\)/ ) do |m|
+#          perm_count+=1
+#        end
+#      end
+#      perm_count.should == 1
+#    end
+  end
+
+  #describe "return values" do
+  #  # FIXME: should do other return thingies here
+  #  it "returns name_content" do
+  #    Card::Query.new( { :name => "A+B", :return => "name_content" } ).run.should == {
+  #      "A+B" => "AlphaBeta"
+  #    }
+  #  end
+  #end
+end