wackamole 0.0.1

data/spec/models/moled_info_spec.rb

@@ -0,0 +1,30 @@
+require File.join(File.dirname(__FILE__), %w[.. spec_helper])
+require 'chronic'
+
+describe Wackamole::MoledInfo do
+  before( :all ) do
+    Wackamole::Control.init_config( File.join(File.dirname(__FILE__), %w[.. config test.yml]), 'test' )
+    Wackamole::Control.connection.should_not be_nil
+    Wackamole::Control.db( "mole_fred_test_mdb" )
+    @test_time = Chronic.parse( "2010/01/01 01:00:00" ).utc     
+  end
+  
+  it "should gather dashboard info correctly" do
+    info = Wackamole::MoledInfo.collect_dashboard_info( @test_time )
+    
+    info[:total_users].should    == 10
+    info[:user_load].should      == 2
+    info[:total_features].should == 10
+    info[:feature_load].should   == 2
+    info[:fault_load].should     == 2
+    info[:perf_load].should      == 2
+    
+    series = 24.times.collect { |i| 0 }
+    series[0] = 5
+    series[1] = 2
+    info[:user_series].should    == series
+    info[:feature_series].should == series
+    info[:fault_series].should   == series
+    info[:perf_series].should    == series
+  end  
+end

data/spec/models/search_filter_spec.rb

@@ -0,0 +1,151 @@
+require File.join(File.dirname(__FILE__), %w[.. spec_helper])
+
+describe Wackamole::SearchFilter do    
+  before( :each ) do
+    @filter = Wackamole::SearchFilter.new
+  end
+  
+  it "should initialize with the correct defaults" do
+     @filter = Wackamole::SearchFilter.new
+     check_filter( @filter, "today", "All", "", -1)
+  end
+  
+  it "should reset a filter correctly" do
+    @filter = Wackamole::SearchFilter.new
+    @filter.time_frame   = "1 year"
+    @filter.browser_type = "Safari"
+    @filter.search_terms = "blee"
+    @filter.feature_id   = 10
+    check_filter( @filter, "1 year", "Safari", "blee", 10 )    
+    @filter.reset!
+    check_filter( @filter, "today", "All", "", -1)
+  end
+  
+  describe "series" do
+    it "should generate the correct time_ids" do
+      @filter.time_frame = "7 days"
+      @filter.time_ids.should have(8).items
+      @filter.time_ids.each { |did| did.size.should == 8 }
+    end
+    
+    it "should generate the correct time series" do
+      @filter.time_frame = "10 days"
+      @filter.time_series.should have(11).items
+      @filter.time_series.each { |date| date.should match( /\d{4}\-\d{2}\-\d{2}/) }
+    end
+  end
+  
+  it "should populate correctly from request params" do
+    @filter.from_options( {:time_frame => '1 year', :browser_type => 'Safari', :search_terms => "blee", :feature_id => 100 } )
+    check_filter( @filter, "1 year", "Safari", "blee", 100 )
+  end
+  
+  describe "#to_conds"
+    before :all do
+      @now = Time.now   
+    end
+    
+    it "should spews default filter query conds correctly" do
+      conds = @filter.to_conds
+      conds.should have(1).item
+      conds.key?( :did ).should == true
+      conds[:did].should == { "$gte" => @now.to_date_id.to_s }
+    end
+    
+    it "should include browser if specified correctly" do
+      @filter.browser_type = 'Safari'
+      conds = @filter.to_conds
+      time = Chronic.parse( "now" ).utc
+      conds.should have(2).items
+      conds.key?( :did ).should == true
+      conds[:did].should == { "$gte" => @now.to_date_id.to_s }
+      conds[:bro].should == "Safari"
+    end
+    
+    it "should include mole type is specfied" do
+      @filter.browser_type = 'Safari'      
+      @filter.type         = Wackamole::SearchFilter.mole_types[1]
+      conds = @filter.to_conds
+      time = Chronic.parse( "now" ).utc  
+      conds.should have(3).items
+      conds.key?( :did ).should == true
+      conds[:did].should == { "$gte" => @now.to_date_id.to_s }
+      conds[:bro].should == "Safari"
+      conds[:typ].should == Rackamole.feature
+    end
+
+    it "should include feature is specfied" do
+      @filter.feature_id = "4b25b0049983a8a193000010"    
+      conds = @filter.to_conds
+      time = Chronic.parse( "now" ).utc
+      conds.should have(2).items
+      conds.key?( :did ).should == true
+      conds[:did].should == { "$gte" => @now.to_date_id.to_s }
+      conds[:fid].should == Mongo::ObjectID.from_string( "4b25b0049983a8a193000010" )
+    end
+    
+    describe "search terms" do
+      before( :all ) do
+        Wackamole::Control.init_config( File.join(File.dirname(__FILE__), %w[.. config test.yml]), 'test' )
+        Wackamole::Control.connection.should_not be_nil
+        Wackamole::Control.db( "mole_fred_test_mdb" )
+      end
+      
+      it "should include user if specified" do
+        @filter.search_terms = "user:blee_0@fred.test"    
+        conds = @filter.to_conds
+        conds.should have(2).items
+        conds[:uid].should_not be_nil
+        conds[:uid].key?( "$in" ).should == true
+        conds[:uid]["$in"].should have(1).item
+        conds[:uid]["$in"].first.to_s.size.should == 24
+      end
+      
+      it "should include an adoc regexp if specified" do
+        @filter.search_terms = "key:blee"    
+        conds = @filter.to_conds
+        conds.should have(2).items
+        conds['key'].should_not be_nil
+        conds['key'].should == /blee/
+      end
+
+      it "should include an adoc regexp if specified" do
+        @filter.search_terms = "key:blee:duh"    
+        conds = @filter.to_conds
+        conds.should have(2).items
+        conds['key.blee'].should_not be_nil
+        conds['key.blee'].should == /duh/
+      end
+      
+      it "should raise an exception is search exp cannot be parsed" do
+        lambda {
+          @filter.search_terms = "key:blee:duh:booba"    
+          conds = @filter.to_conds          
+        }.should raise_error /Unable to evaluate search terms/
+      end
+    end
+    
+    describe "#map_mole_type" do
+      it "should map mole types correctly" do
+        %w[Feature Perf Fault].each { |type| @filter.send( :map_mole_type, type ).should == Rackamole.send( type.downcase ) }
+      end
+      
+      it "should crap out for invalid mole types" do
+        lambda {
+          @filter.send( :map_mole_type, "bozo" )
+        }.should raise_error( /Invalid mole type `bozo/ )
+      end
+    end
+    
+    it "should reset a time stamp correctly" do
+      @filter.send( :now ).strftime( "%H:%M:%S" ).should match( /00\:00\:00/ )
+    end
+end
+
+
+def check_filter( filter, time_frame, browser, terms, feature_id )
+  filter.time_frame.should   == time_frame
+  filter.browser_type.should == browser
+  filter.search_terms.should == terms
+  filter.feature_id.should   == feature_id
+end

data/spec/models/user_spec.rb

@@ -0,0 +1,44 @@
+require File.join(File.dirname(__FILE__), %w[.. spec_helper])
+require 'chronic'
+
+describe Wackamole::User do
+  before( :all ) do
+    Wackamole::Control.init_config( File.join(File.dirname(__FILE__), %w[.. config test.yml]), 'test' )
+    Wackamole::Control.connection.should_not be_nil
+    Wackamole::Control.db( "mole_fred_test_mdb" )
+  end
+  
+  it "should paginate a user collection correctly" do
+    cltn = Wackamole::User.paginate_tops( {}, 1, 2 )
+    cltn.total_entries.should == 7
+    cltn.size.should == 2
+    cltn.total_pages.should == 4
+  end
+  
+  describe "indexes" do
+    before :all do
+      @cltn = Wackamole::User.users_cltn
+      @cltn.should_not be_nil
+      @cltn.drop_indexes
+    end
+    
+    it "should set up indexes correctly" do
+      indexes = @cltn.index_information
+      indexes.should have(1).item  
+      count = Wackamole::User.ensure_indexes!  
+      count.should == 1
+      indexes = @cltn.index_information
+      indexes.should have(2).items
+    end
+    
+    it "should do nothing if indexes are already present" do
+      indexes = @cltn.index_information
+      indexes.should have(2).items   
+      count = Wackamole::User.ensure_indexes!
+      count.should == 1
+      indexes = @cltn.index_information
+      indexes.should have(2).items      
+    end
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+require 'rubygems'
+require 'mongo'
+require 'rackamole'
+gem     'agnostic-will_paginate'
+require 'will_paginate'
+require 'forwardable'
+
+require File.expand_path( File.join(File.dirname(__FILE__), %w[data fixtures]))
+require File.expand_path( File.join(File.dirname(__FILE__), %w[.. lib wackamole]))
+
+# BOZO !! To run test you'll need to start a mongo instance
+# mongod --dbpath /data/wackamole/ --port 27777
+Spec::Runner.configure do |config|
+end

data/spec/wackamole_spec.rb

@@ -0,0 +1,20 @@
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+describe Wackamole do
+ before( :all ) do        
+    @root = ::File.expand_path( ::File.join(::File.dirname(__FILE__), ".." ) )
+  end
+    
+  it "is versioned" do
+    Wackamole.version.should =~ /\d+\.\d+\.\d+/
+  end
+  
+  it "generates a correct path relative to root" do
+    Wackamole.path( "wackamole.rb" ).should == ::File.join(@root, "wackamole.rb" )
+  end
+  
+  it "generates a correct path relative to lib" do
+    Wackamole.libpath(%w[ models control.rb]).should == ::File.join( @root, "lib", "models", "control.rb" )
+  end       
+  
+end

data/tasks/bones.rake

@@ -0,0 +1,20 @@
+
+if HAVE_BONES
+
+namespace :bones do
+
+  desc 'Show the PROJ open struct'
+  task :debug do |t|
+    atr = if t.application.top_level_tasks.length == 2
+      t.application.top_level_tasks.pop
+    end
+
+    if atr then Bones::Debug.show_attr(PROJ, atr)
+    else Bones::Debug.show PROJ end
+  end
+
+end  # namespace :bones
+
+end  # HAVE_BONES
+
+# EOF

data/tasks/fixtures.rake

@@ -0,0 +1,13 @@
+namespace :fixtures do
+
+  # A prerequisites task that all other tasks depend upon
+  task :prereqs
+
+  desc 'Populate fixture data'
+  task :load do |t|
+    Fixtures.load_data    
+  end  
+
+# task 'gem:release' => 'svn:create_tag'
+end
+

data/tasks/gem.rake

@@ -0,0 +1,201 @@
+
+require 'find'
+require 'rake/packagetask'
+require 'rubygems/user_interaction'
+require 'rubygems/builder'
+
+module Bones
+class GemPackageTask < Rake::PackageTask
+  # Ruby GEM spec containing the metadata for this package.  The
+  # name, version and package_files are automatically determined
+  # from the GEM spec and don't need to be explicitly provided.
+  #
+  attr_accessor :gem_spec
+
+  # Tasks from the Bones gem directory
+  attr_reader :bones_files
+
+  # Create a GEM Package task library.  Automatically define the gem
+  # if a block is given.  If no block is supplied, then +define+
+  # needs to be called to define the task.
+  #
+  def initialize(gem_spec)
+    init(gem_spec)
+    yield self if block_given?
+    define if block_given?
+  end
+
+  # Initialization tasks without the "yield self" or define
+  # operations.
+  #
+  def init(gem)
+    super(gem.name, gem.version)
+    @gem_spec = gem
+    @package_files += gem_spec.files if gem_spec.files
+    @bones_files = []
+
+    local_setup = File.join(Dir.pwd, %w[tasks setup.rb])
+    if !test(?e, local_setup)
+      Dir.glob(::Bones.path(%w[lib bones tasks *])).each {|fn| bones_files << fn}
+    end
+  end
+
+  # Create the Rake tasks and actions specified by this
+  # GemPackageTask.  (+define+ is automatically called if a block is
+  # given to +new+).
+  #
+  def define
+    super
+    task :prereqs
+    task :package => ['gem:prereqs', "#{package_dir_path}/#{gem_file}"]
+    file "#{package_dir_path}/#{gem_file}" => [package_dir_path] + package_files + bones_files do
+      when_writing("Creating GEM") {
+        chdir(package_dir_path) do
+          Gem::Builder.new(gem_spec).build
+          verbose(true) {
+            mv gem_file, "../#{gem_file}"
+          }
+        end
+      }
+    end
+
+    file package_dir_path => bones_files do
+      mkdir_p package_dir rescue nil
+
+      gem_spec.files = (gem_spec.files +
+          bones_files.map {|fn| File.join('tasks', File.basename(fn))}).sort
+
+      bones_files.each do |fn|
+        base_fn = File.join('tasks', File.basename(fn))
+        f = File.join(package_dir_path, base_fn)
+        fdir = File.dirname(f)
+        mkdir_p(fdir) if !File.exist?(fdir)
+        if File.directory?(fn)
+          mkdir_p(f)
+        else
+          raise "file name conflict for '#{base_fn}' (conflicts with '#{fn}')" if test(?e, f)
+          safe_ln(fn, f)
+        end
+      end
+    end
+  end
+  
+  def gem_file
+    if @gem_spec.platform == Gem::Platform::RUBY
+      "#{package_name}.gem"
+    else
+      "#{package_name}-#{@gem_spec.platform}.gem"
+    end
+  end
+end  # class GemPackageTask
+end  # module Bones
+
+namespace :gem do
+
+  PROJ.gem._spec = Gem::Specification.new do |s|
+    s.name = PROJ.name
+    s.version = PROJ.version
+    s.summary = PROJ.summary
+    s.authors = Array(PROJ.authors)
+    s.email = PROJ.email
+    s.homepage = Array(PROJ.url).first
+    s.rubyforge_project = PROJ.rubyforge.name
+
+    s.description = PROJ.description
+
+    PROJ.gem.dependencies.each do |dep|
+      s.add_dependency(*dep)
+    end
+
+    PROJ.gem.development_dependencies.each do |dep|
+      s.add_development_dependency(*dep)
+    end
+
+    s.files = PROJ.gem.files
+    s.executables = PROJ.gem.executables.map {|fn| File.basename(fn)}
+    s.extensions = PROJ.gem.files.grep %r/extconf\.rb$/
+
+    s.bindir = 'bin'
+    dirs = Dir["{#{PROJ.libs.join(',')}}"]
+    s.require_paths = dirs unless dirs.empty?
+
+    incl = Regexp.new(PROJ.rdoc.include.join('|'))
+    excl = PROJ.rdoc.exclude.dup.concat %w[\.rb$ ^(\.\/|\/)?ext]
+    excl = Regexp.new(excl.join('|'))
+    rdoc_files = PROJ.gem.files.find_all do |fn|
+                   case fn
+                   when excl; false
+                   when incl; true
+                   else false end
+                 end
+    s.rdoc_options = PROJ.rdoc.opts + ['--main', PROJ.rdoc.main]
+    s.extra_rdoc_files = rdoc_files
+    s.has_rdoc = true
+
+    if test ?f, PROJ.test.file
+      s.test_file = PROJ.test.file
+    else
+      s.test_files = PROJ.test.files.to_a
+    end
+
+    # Do any extra stuff the user wants
+    PROJ.gem.extras.each do |msg, val|
+      case val
+      when Proc
+        val.call(s.send(msg))
+      else
+        s.send "#{msg}=", val
+      end
+    end
+  end  # Gem::Specification.new
+
+  Bones::GemPackageTask.new(PROJ.gem._spec) do |pkg|
+    pkg.need_tar = PROJ.gem.need_tar
+    pkg.need_zip = PROJ.gem.need_zip
+  end
+
+  desc 'Show information about the gem'
+  task :debug => 'gem:prereqs' do
+    puts PROJ.gem._spec.to_ruby
+  end
+
+  desc 'Write the gemspec '
+  task :spec => 'gem:prereqs' do
+    File.open("#{PROJ.name}.gemspec", 'w') do |f|
+      f.write PROJ.gem._spec.to_ruby
+    end
+  end
+
+  desc 'Install the gem'
+  task :install => [:clobber, 'gem:package'] do
+    sh "#{SUDO} #{GEM} install --local pkg/#{PROJ.gem._spec.full_name}"
+
+    # use this version of the command for rubygems > 1.0.0
+    #sh "#{SUDO} #{GEM} install --no-update-sources pkg/#{PROJ.gem._spec.full_name}"
+  end
+
+  desc 'Uninstall the gem'
+  task :uninstall do
+    installed_list = Gem.source_index.find_name(PROJ.name)
+    if installed_list and installed_list.collect { |s| s.version.to_s}.include?(PROJ.version) then
+      sh "#{SUDO} #{GEM} uninstall --version '#{PROJ.version}' --ignore-dependencies --executables #{PROJ.name}"
+    end
+  end
+
+  desc 'Reinstall the gem'
+  task :reinstall => [:uninstall, :install]
+
+  desc 'Cleanup the gem'
+  task :cleanup do
+    sh "#{SUDO} #{GEM} cleanup #{PROJ.gem._spec.name}"
+  end
+end  # namespace :gem
+
+
+desc 'Alias to gem:package'
+task :gem => 'gem:package'
+
+task :clobber => 'gem:clobber_package'
+remove_desc_for_task 'gem:clobber_package'
+
+# EOF