require 'spec_helper'

describe '#keys()' do

  it "returns [] when no keys are found (no regex characters)" do
    @redises.keys("mock-redis-test:29016").should == []
  end

  it "returns [] when no keys are found (some regex characters)" do
    @redises.keys("mock-redis-test:29016*").should == []
  end

  describe "with pattern matching" do
    before do
      @redises.set("mock-redis-test:key",   0)
      @redises.set("mock-redis-test:key1",  1)
      @redises.set("mock-redis-test:key2",  2)
      @redises.set("mock-redis-test:key3",  3)
      @redises.set("mock-redis-test:key10", 10)
      @redises.set("mock-redis-test:key20", 20)
      @redises.set("mock-redis-test:key30", 30)

      @redises.set("mock-redis-test:regexp-key(1|22)", 40)
      @redises.set("mock-redis-test:regexp-key3+", 40)
      @redises.set("mock-redis-test:regexp-key33", 40)
      @redises.set("mock-redis-test:regexp-key4a", 40)
      @redises.set("mock-redis-test:regexp-key4-", 40)
      @redises.set("mock-redis-test:regexp-key4b", 40)
      @redises.set("mock-redis-test:regexp-key4c", 40)

      @redises.set("mock-redis-test:special-key?", 'true')
      @redises.set("mock-redis-test:special-key*", 'true')
    end

    describe "the ? character" do
      it "is treated as a single character (at the end of the pattern)" do
        @redises.keys("mock-redis-test:key?").sort.should == [
          'mock-redis-test:key1',
          'mock-redis-test:key2',
          'mock-redis-test:key3',
        ]
      end

      it "is treated as a single character (in the middle of the pattern)" do
        @redises.keys("mock-redis-test:key?0").sort.should == [
          'mock-redis-test:key10',
          'mock-redis-test:key20',
          'mock-redis-test:key30',
        ]
      end

      it "treats \? as a literal ?" do
        @redises.keys('mock-redis-test:special-key\?').sort.should == [
          'mock-redis-test:special-key?'
        ]
      end
    end

    describe "the * character" do
      it "is treated as 0 or more characters" do
        @redises.keys("mock-redis-test:key*").sort.should == [
          'mock-redis-test:key',
          'mock-redis-test:key1',
          'mock-redis-test:key10',
          'mock-redis-test:key2',
          'mock-redis-test:key20',
          'mock-redis-test:key3',
          'mock-redis-test:key30',
        ]
      end

      it "treats \* as a literal *" do
        @redises.keys('mock-redis-test:special-key\*').sort.should == [
          'mock-redis-test:special-key*'
        ]
      end
    end

    describe "character classes ([abcde])" do
      it "matches any one of those characters" do
        @redises.keys('mock-redis-test:key[12]').sort.should == [
          'mock-redis-test:key1',
          'mock-redis-test:key2',
        ]
      end
    end

    describe "the | character" do
      it "is treated as literal (not 'or')" do
        @redises.keys('mock-redis-test:regexp-key(1|22)').sort.should == [
          'mock-redis-test:regexp-key(1|22)'
        ]
      end
    end

    describe "the + character" do
      it "is treated as literal (not 'one or more' quantifier)" do
        @redises.keys('mock-redis-test:regexp-key3+').sort.should == [
          'mock-redis-test:regexp-key3+'
        ]
      end
    end

    describe "character classes ([a-c])" do
      it "specifies a range which matches any lowercase letter from \"a\" to \"c\"" do
        @redises.keys('mock-redis-test:regexp-key4[a-c]').sort.should == [
          'mock-redis-test:regexp-key4a',
          'mock-redis-test:regexp-key4b',
          'mock-redis-test:regexp-key4c',
        ]
      end
    end

    describe "combining metacharacters" do
      it "works with different metacharacters simultaneously" do
        @redises.keys('mock-redis-test:k*[12]?').sort.should == [
          'mock-redis-test:key10',
          'mock-redis-test:key20',
        ]
      end
    end
  end
end