mongoid_token 1.1.1 → 2.0.0

data/lib/mongoid_token.rb

@@ -1,116 +1 @@
-require 'mongoid/token/exceptions'
-
-module Mongoid
-  module Token
-    extend ActiveSupport::Concern
-
-    module ClassMethods
-      def token(*args)
-        options = args.extract_options!
-        options[:length] ||= 4
-        options[:retry] ||= 3
-        options[:contains] ||= :alphanumeric
-        options[:field_name] ||= :token
-        #options[:key] ||= false
-
-        self.field options[:field_name].to_sym, :type => String
-        self.index({ options[:field_name].to_sym => 1 }, { :unique => true })
-
-        #if options[:key]
-        #  self.key options[:field_name].to_sym
-        #end
-
-        set_callback(:create, :before) do |document|
-          document.create_token(options[:length], options[:contains])
-        end
-
-        set_callback(:save, :before) do |document|
-          document.create_token_if_nil(options[:length], options[:contains])
-        end
-
-        after_initialize do # set_callback did not work with after_initialize callback
-          self.instance_variable_set :@max_collision_retries, options[:retry]
-          self.instance_variable_set :@token_field_name, options[:field_name]
-          self.instance_variable_set :@token_length, options[:length]
-          self.instance_variable_set :@token_contains, options[:contains]
-        end
-
-        if options[:retry] > 0
-          alias_method_chain :insert, :safety
-          alias_method_chain :upsert, :safety
-        end
-
-        self.class_variable_set :@@token_field_name, options[:field_name]
-      end
-
-      def find_by_token(token)
-        field_name = self.class_variable_get :@@token_field_name
-        self.find_by(field_name.to_sym => token)
-      end
-    end
-
-    def to_param
-      self.send(@token_field_name.to_sym) || super
-    end
-
-    protected
-
-    def resolve_token_collisions
-      retries = @max_collision_retries
-
-      begin
-        yield
-      rescue Moped::Errors::OperationFailure => e
-        # This is horrible, but seems to be the only way to get the details of the exception?
-        continue unless [11000, 11001].include?(e.details['code'])
-        continue unless   e.details['err'] =~ /dup key/ &&
-                          e.details['err'] =~ /"#{self.send(@token_field_name.to_sym)}"/
-
-        if (retries -= 1) > 0
-          self.create_token(@token_length, @token_contains)
-          retry
-        else
-          Rails.logger.warn "[Mongoid::Token] Warning: Maximum to generation retries (#{@max_collision_retries}) exceeded." if defined?(Rails) && Rails.env == 'development'
-          raise Mongoid::Token::CollisionRetriesExceeded.new(self, @max_collision_retries)
-        end
-      end
-    end
-
-    def insert_with_safety(options = {})
-      resolve_token_collisions { with(:safe => true).insert_without_safety(options) }
-    end
-
-    def upsert_with_safety(options = {})
-      resolve_token_collisions { with(:safe => true).upsert_without_safety(options) }
-    end
-
-    def create_token(length, characters)
-      self.send(:"#{@token_field_name}=", self.generate_token(length, characters))
-    end
-
-    def create_token_if_nil(length, characters)
-      if self[@token_field_name.to_sym].blank?
-        self.create_token(length, characters) 
-      end
-    end
-
-    def generate_token(length, characters = :alphanumeric)
-      case characters
-      when :alphanumeric
-        (1..length).collect { (i = Kernel.rand(62); i += ((i < 10) ? 48 : ((i < 36) ? 55 : 61 ))).chr }.join
-      when :numeric
-        rand(10**length).to_s
-      when :fixed_numeric
-        rand(10**length).to_s.rjust(length,rand(10).to_s)
-      when :fixed_numeric_no_leading_zeros
-        (rand(10**length - 10**(length-1)) + 10**(length-1)).to_s
-      when :alpha
-        Array.new(length).map{['A'..'Z','a'..'z'].map{|r|r.to_a}.flatten[rand(52)]}.join
-      when :alpha_lower
-        Array.new(length).map{['a'..'z'].map{|r|r.to_a}.flatten[rand(26)]}.join
-      when :alpha_upper
-        Array.new(length).map{['A'..'Z'].map{|r|r.to_a}.flatten[rand(26)]}.join
-      end
-    end
-  end
-end
+require 'mongoid/token'

data/lib/version.rb

@@ -1,3 +1,3 @@
 module MongoidToken
-  VERSION = "1.1.1"
+  VERSION = "2.0.0"
 end

data/spec/mongoid/token/collisions_spec.rb

@@ -0,0 +1,92 @@
+require File.join(File.dirname(__FILE__), %w[.. .. spec_helper])
+
+describe Mongoid::Token::Collisions do
+  let(:document) { Object.new }
+  describe "#resolve_token_collisions" do
+    context "when there is a duplicate token" do
+      let(:resolver) { double("Mongoid::Token::CollisionResolver") }
+
+      before(:each) do
+        resolver.stub(:field_name).and_return(:token)
+        resolver.stub(:create_new_token_for){|doc|}
+        document.class.send(:include, Mongoid::Token::Collisions)
+        document.stub(:is_duplicate_token_error?).and_return(true)
+      end
+
+      context "and there are zero retries" do
+        it "should raise an error after the first try" do
+          resolver.stub(:retry_count).and_return(0)
+          attempts = 0
+          expect{document.resolve_token_collisions(resolver) { attempts += 1; raise Moped::Errors::OperationFailure.new("","") }}.to raise_error Mongoid::Token::CollisionRetriesExceeded
+          expect(attempts).to eq 1
+        end
+      end
+
+      context "and retries is set to 1" do
+        it "should raise an error after retrying once" do
+          resolver.stub(:retry_count).and_return(1)
+          attempts = 0
+          expect{document.resolve_token_collisions(resolver) { attempts += 1; raise Moped::Errors::OperationFailure.new("","") }}.to raise_error Mongoid::Token::CollisionRetriesExceeded
+          expect(attempts).to eq 2
+        end
+      end
+
+      context "and retries is greater than 1" do
+        it "should raise an error after retrying" do
+          resolver.stub(:retry_count).and_return(3)
+          attempts = 0
+          expect{document.resolve_token_collisions(resolver) { attempts += 1; raise Moped::Errors::OperationFailure.new("","") }}.to raise_error Mongoid::Token::CollisionRetriesExceeded
+          expect(attempts).to eq 4
+        end
+      end
+    end
+  end
+
+  describe "#raise_collision_retries_exceeded_error" do
+    before(:each) do
+      document.class.send(:include, Mongoid::Token::Collisions)
+    end
+
+    it "should warn the rails logger" do
+      message = nil
+
+      stub_const("Rails", Class.new)
+
+      logger = double("logger")
+      logger.stub("warn"){ |msg| message = msg }
+      Rails.stub("logger").and_return(logger)
+
+      begin
+        document.raise_collision_retries_exceeded_error(:token, 3)
+      rescue
+      end
+      expect(message).to_not be_nil
+    end
+
+    it "should raise an error" do
+      expect{ document.raise_collision_retries_exceeded_error(:token, 3) }.to raise_error(Mongoid::Token::CollisionRetriesExceeded)
+    end
+  end
+
+  describe "#is_duplicate_token_error?" do
+    before(:each) do
+      document.class.send(:include, Mongoid::Token::Collisions)
+    end
+    context "when there is a duplicate key error" do
+      it "should return true" do
+        document.stub("token").and_return("tokenvalue123")
+        err = double("Moped::Errors::OperationFailure")
+        err.stub("details").and_return do
+          {
+            "err" => "E11000 duplicate key error index: mongoid_token_test.links.$token_1  dup key: { : \"tokenvalue123\" }",
+            "code" => 11000,
+            "n" => 0,
+            "connectionId" => 130,
+            "ok" => 1.0
+          }
+          document.is_duplicate_token_error?(err, document, :token)
+        end
+      end
+    end
+  end
+end

data/spec/mongoid/token/exceptions_spec.rb

@@ -0,0 +1,4 @@
+require File.join(File.dirname(__FILE__), %w[.. .. spec_helper])
+
+describe Mongoid::Token::CollisionRetriesExceeded do
+end

data/spec/mongoid/token/finders_spec.rb

@@ -0,0 +1,41 @@
+require File.join(File.dirname(__FILE__), %w[.. .. spec_helper])
+
+describe Mongoid::Token::Finders do
+  before :each do
+  end
+
+  it "define a finder based on a field_name" do
+    klass = Class.new
+    field = :another_token
+    Mongoid::Token::Finders.define_custom_token_finder_for(klass, field)
+    klass.singleton_methods.should include(:"find_by_#{field}")
+  end
+
+  it "override the `find` method of the document" do
+    klass = Class.new 
+    klass.define_singleton_method(:find) {|*args| :original_find }
+    klass.define_singleton_method(:find_by) {|*args| :token_find }
+
+    Mongoid::Token::Finders.define_custom_token_finder_for(klass)
+
+    klass.find(Moped::BSON::ObjectId.new).should == :original_find
+    klass.find(Moped::BSON::ObjectId.new, Moped::BSON::ObjectId.new).should == :original_find
+    klass.find().should == :original_find
+    klass.find(Moped::BSON::ObjectId.new, "token").should == :token_find
+    klass.find("token").should == :token_find
+  end
+
+  it "retrieve a document using the dynamic finder" do
+    class Document; include Mongoid::Document; field :token; end
+    document = Document.create!(:token => "1234")
+    Mongoid::Token::Finders.define_custom_token_finder_for(Document)
+    Document.find_by_token("1234").should == document
+  end
+
+  it "retrieve a document using the `find` method" do
+    class Document; include Mongoid::Document; field :token; end
+    document = Document.create! :token => "1234"
+    Mongoid::Token::Finders.define_custom_token_finder_for(Document)
+    Document.find("1234").should == document
+  end
+end

data/spec/mongoid/token/generator_spec.rb

@@ -0,0 +1,49 @@
+require File.join(File.dirname(__FILE__), %w[.. .. spec_helper])
+
+describe Mongoid::Token::Generator do
+  describe "#generate" do
+    it "generates lowercase characters" do
+      100.times{ Mongoid::Token::Generator.generate("%c").should =~ /[a-z]/ }
+    end
+
+    it "generates uppercase characters" do
+      100.times{ Mongoid::Token::Generator.generate("%C").should =~ /[A-Z]/ }
+    end
+
+    it "generates digits" do
+      100.times{ Mongoid::Token::Generator.generate("%d").should =~ /[0-9]/ }
+    end
+
+    it "generates non-zero digits" do
+      100.times{ Mongoid::Token::Generator.generate("%D").should =~ /[1-9]/ }
+    end
+
+    it "generates alphanumeric characters" do
+      100.times{ Mongoid::Token::Generator.generate("%s").should =~ /[A-Za-z0-9]/ }
+    end
+
+    it "generates upper and lowercase characters" do
+      100.times{ Mongoid::Token::Generator.generate("%w").should =~ /[A-Za-z]/ }
+    end
+
+    it "generates URL-safe punctuation" do
+      100.times{ Mongoid::Token::Generator.generate("%p").should =~ /[\.\-\_\=\+\$]/ }
+    end
+
+    it "generates patterns of a fixed length" do
+      100.times{ Mongoid::Token::Generator.generate("%s8").should =~ /[A-Za-z0-9]{8}/ }
+    end
+
+    it "generates patterns of a variable length" do
+      100.times{ Mongoid::Token::Generator.generate("%s1,5").should =~ /[A-Za-z0-9]{1,5}/ }
+    end
+
+    it "generates patterns with static prefixes/suffixes" do
+      100.times { Mongoid::Token::Generator.generate("prefix-%s4-suffix").should =~ /prefix\-[A-Za-z0-9]{4}\-suffix/ }
+    end
+
+    it "generates more complex patterns" do
+      100.times { Mongoid::Token::Generator.generate("pre-%d4-%C3-%d4").should =~ /pre\-[0-9]{4}\-[A-Z]{3}\-[0-9]{4}/ }
+    end
+  end
+end

data/spec/mongoid/token/options_spec.rb

@@ -0,0 +1,70 @@
+require File.join(File.dirname(__FILE__), %w[.. .. spec_helper])
+
+describe Mongoid::Token::Options do
+  before do
+    @options = Mongoid::Token::Options.new(
+      {
+        :length => 9999,
+        :retry_count => 8888,
+        :contains => :nonsense,
+        :field_name => :not_a_token
+      }
+    )
+  end
+
+  it "should have a length" do
+    @options.length.should == 9999
+  end
+
+  it "should default to a length of 4" do
+    Mongoid::Token::Options.new.length.should == 4
+  end
+
+  it "should have a retry count" do
+    @options.retry_count.should == 8888
+  end
+
+  it "should default to a retry count of 3" do
+    Mongoid::Token::Options.new.retry_count.should == 3
+  end
+
+  it "should have a list of characters to contain" do
+    @options.contains.should == :nonsense
+  end
+
+  it "should default to an alphanumeric set of characters to contain" do
+    Mongoid::Token::Options.new.contains.should == :alphanumeric
+  end
+
+  it "should have a field name" do
+    @options.field_name.should == :not_a_token
+  end
+
+  it "should default to a field name of 'token'" do
+    Mongoid::Token::Options.new.field_name.should == :token
+  end
+
+  it "should create a pattern" do
+    Mongoid::Token::Options.new.pattern.should == "%s4"
+  end
+
+  describe "override_to_param" do
+    it "should be an option" do
+      expect(Mongoid::Token::Options.new({:override_to_param => false}).override_to_param?).to eq false
+    end
+
+    it "should default to true" do
+      expect(Mongoid::Token::Options.new.override_to_param?).to eq true
+    end
+  end
+
+   describe "skip_finder" do
+    it "should be an option" do
+      expect(Mongoid::Token::Options.new({:skip_finders => true}).skip_finders?).to eq true
+    end
+
+    it "should default to false" do
+      expect(Mongoid::Token::Options.new.skip_finders?).to eq false
+    end
+  end
+end