fluidfeatures 0.5.0 → 0.6.0

data/.travis.yml

@@ -4,4 +4,3 @@ rvm:
 gemfile:
   - Gemfile
 script: bundle exec rake spec
-env: FLUIDFEATURES_APPID=1vu33ki6emqe3 FLUIDFEATURES_SECRET=secret FLUIDFEATURES_BASEURI=https://www.fluidfeatures.com/service

data/README.md

@@ -35,8 +35,8 @@ Call `app` on the `FluidFeatures` module to instantiate this object.
 require 'fluidfeatures'
 
 config = {
-  "baseuri" => "https://www.fluidfeatures.com/service"
-  "appid" => "1vu33ki6emqe3"
+  "base_uri" => "https://www.fluidfeatures.com/service"
+  "app_id" => "1vu33ki6emqe3"
   "secret" = "sssseeecrrreeetttt"
 }
 

data/lib/fluidfeatures/app/reporter.rb

@@ -27,13 +27,26 @@ module FluidFeatures
     
     def initialize(app)
       raise "app invalid : #{app}" unless app.is_a? ::FluidFeatures::App
+      @sending = false
       configure(app)
-      run_loop
       at_exit do
         buckets_storage.append(@buckets)
       end
     end
 
+    def start_sending
+      return if @sending
+      @sending = true
+      run_loop
+    end
+
+    def stop_sending(wait=false)
+      @sending = false
+      if wait
+        @loop_thread.join if @loop_thread and @loop_thread.alive?
+      end
+    end
+
     def buckets_storage
       @buckets_storage ||= FluidFeatures::Persistence::Buckets.create(FluidFeatures.config["cache"])
     end
@@ -96,48 +109,66 @@ module FluidFeatures
         features_storage.replace_unknown(@unknown_features)
       end
 
+      start_sending unless @sending
     end
 
     def run_loop
-      Thread.new do
-        while true
-          begin
 
-            unless transactions_queued?
-              sleep WAIT_BETWEEN_QUEUE_EMTPY_CHECKS
-              next
-            end
+      return unless @sending
+      return if @loop_thread and @loop_thread.alive?
+
+      @loop_thread = Thread.new do
+        while @sending
+          run_loop_iteration(
+            WAIT_BETWEEN_QUEUE_EMTPY_CHECKS,
+            WAIT_BETWEEN_SEND_SUCCESS_NONE_WAITING,
+            WAIT_BETWEEN_SEND_SUCCESS_NEXT_WAITING,
+            WAIT_BETWEEN_SEND_FAILURES
+          )
+        end
+      end
+    end
 
-            success = send_transactions
-
-            if success
-              # Unless we have a full bucket waiting do not make
-              # more than N requests per second.
-              if bucket_count <= 1
-                sleep WAIT_BETWEEN_SEND_SUCCESS_NONE_WAITING
-              else
-                sleep WAIT_BETWEEN_SEND_SUCCESS_NEXT_WAITING
-              end
-            else  
-              # If service is down, then slow our requests
-              # within this thread
-              sleep WAIT_BETWEEN_SEND_FAILURES
-            end
+    def run_loop_iteration(
+      wait_between_queue_emtpy_checks,
+      wait_between_send_success_none_waiting,
+      wait_between_send_success_next_waiting,
+      wait_between_send_failures)
+      begin
+
+        unless transactions_queued?
+          sleep wait_between_queue_emtpy_checks
+          return
+        end
 
-          rescue Exception => err
-            # catch errors, so that we do not affect the rest of the application
-            app.logger.error "[FF] send_transactions failed : #{err.message}\n#{err.backtrace.join("\n")}"
-            # hold off for a little while and try again
-            sleep WAIT_BETWEEN_SEND_FAILURES
+        success = send_transactions
+
+        if success
+          # Unless we have a full bucket waiting do not make
+          # more than N requests per second.
+          if bucket_count <= 1
+            sleep wait_between_send_success_none_waiting
+          else
+            sleep wait_between_send_success_next_waiting
           end
+        else  
+          # If service is down, then slow our requests
+          # within this thread
+          sleep wait_between_send_failures
         end
+
+      rescue Exception => err
+        # catch errors, so that we do not affect the rest of the application
+        app.logger.error "[FF] send_transactions failed : #{err.message}\n#{err.backtrace.join("\n")}"
+        # hold off for a little while and try again
+        sleep wait_between_send_failures
       end
     end
 
     @private
     def transactions_queued?
       have_transactions = false
-      @buckets_lock.synchronize do
+      buckets_lock_synchronize do
         if @buckets.size == 1
           @current_bucket_lock.synchronize do
             if @current_bucket.size > 0
@@ -163,7 +194,7 @@ module FluidFeatures
       end
 
       remaining_buckets_stats = nil
-      @buckets_lock.synchronize do
+      buckets_lock_synchronize do
         remaining_buckets_stats = @buckets.map { |b| b.size }
       end
 
@@ -205,7 +236,7 @@ module FluidFeatures
     @private
     def bucket_count
       num_buckets = 0
-      @buckets_lock.synchronize do
+      buckets_lock_synchronize do
         num_buckets = @buckets.size
       end
       num_buckets
@@ -214,7 +245,7 @@ module FluidFeatures
     @private
     def new_bucket
       bucket = []
-      @buckets_lock.synchronize do
+      buckets_lock_synchronize do
         @buckets << bucket
         if @buckets.size > MAX_BUCKETS
           #offload to storage
@@ -229,7 +260,7 @@ module FluidFeatures
     @private
     def remove_bucket
       removed_bucket = nil
-      @buckets_lock.synchronize do
+      buckets_lock_synchronize do
         #try to get buckets from storage first
         if @buckets.empty? && !buckets_storage.empty?
           @buckets = buckets_storage.fetch(MAX_BUCKETS)
@@ -251,7 +282,7 @@ module FluidFeatures
     @private
     def unremove_bucket(bucket)
       success = false
-      @buckets_lock.synchronize do
+      buckets_lock_synchronize do
         if @buckets.size <= MAX_BUCKETS
           @buckets.unshift bucket
           success = true
@@ -292,5 +323,12 @@ module FluidFeatures
       end
     end
 
+    @private
+    def buckets_lock_synchronize
+      @buckets_lock.synchronize do
+        yield
+      end
+    end
+
   end
 end

data/lib/fluidfeatures/app/state.rb

@@ -4,6 +4,7 @@ require "thread"
 
 require "fluidfeatures/const"
 require "fluidfeatures/app/transaction"
+require "fluidfeatures/exceptions"
 
 module FluidFeatures
   class AppState
@@ -29,70 +30,121 @@ module FluidFeatures
 
     def initialize(app)
       raise "app invalid : #{app}" unless app.is_a? ::FluidFeatures::App
+      @receiving = false
       configure(app)
-      run_loop
     end
 
     def configure(app)
       @app = app
-      @features = features_storage.list
+      @features = nil
       @features_lock = ::Mutex.new
     end
 
+    def start_receiving
+      return if @receiving
+      @receiving = true
+      run_loop
+    end
+
+    def stop_receiving(wait=false)
+      @receiving = false
+      if wait
+        @loop_thread.join if @loop_thread and @loop_thread.alive?
+      end
+    end
+
     def features_storage
       @features_storage ||= FluidFeatures::Persistence::Features.create(FluidFeatures.config["cache"])
     end
 
     def features
       f = nil
-      @features_lock.synchronize do
-        f = @features
+      if @receiving
+        # use features loaded in background
+        features_lock_synchronize do
+          f = @features
+        end
+      end
+      unless f
+        # we have not loaded features yet.
+        # load in foreground but do not use caching (etags)
+        success, state = load_state(use_cache=false)
+        if success
+          unless state
+            # Since we did not use etag caching, state should never
+            # be nil if success was true.
+            raise FFeaturesAppStateLoadFailure.new("Unexpected nil state returned from successful load_state(use_cache=false).")
+          end
+          self.features = f = state
+        else
+          # fluidfeatures API must be down.
+          # load persisted features from disk.
+          self.features = f = features_storage.list
+        end
+      end
+      # we should never return nil
+      unless f
+        # If we still could not load state then croak
+        raise FFeaturesAppStateLoadFailure.new("Could not load features state from API: #{state}")
+      end
+      unless @receiving
+        # start background receiver loop
+        start_receiving
       end
       f
     end
 
     def features= f
       return unless f.is_a? Hash
-      @features_lock.synchronize do
-        features_storage.replace(f) unless @features == f
+      features_lock_synchronize do
+        features_storage.replace(f)
         @features = f
       end
+      f
     end
 
     def run_loop
-      Thread.new do
-        while true
-          begin
-
-            success, state = load_state
-
-            # Note, success could be true, but state might be nil.
-            # This occurs with 304 (no change)
-            if success and state
-              # switch out current state with new one
-              self.features = state
-            elsif not success
-              # If service is down, then slow our requests
-              # within this thread
-              sleep WAIT_BETWEEN_FETCH_FAILURES
-            end
 
-            # What ever happens never make more than N requests
-            # per second
-            sleep WAIT_BETWEEN_FETCH_SUCCESS
+      return unless @receiving
+      return if @loop_thread and @loop_thread.alive?
 
-          rescue Exception => err
-            # catch errors, so that we do not affect the rest of the application
-            app.logger.error "load_state failed : #{err.message}\n#{err.backtrace.join("\n")}"
-            # hold off for a little while and try again
-            sleep WAIT_BETWEEN_FETCH_FAILURES
-          end
+      @loop_thread = Thread.new do
+        while @receiving
+          run_loop_iteration(WAIT_BETWEEN_FETCH_SUCCESS, WAIT_BETWEEN_FETCH_FAILURES)
+        end
+      end
+    end
+
+    def run_loop_iteration(wait_between_fetch_success, wait_between_fetch_failures)
+      begin
+
+        success, state = load_state
+
+        # Note, success could be true, but state might be nil.
+        # This occurs with 304 (no change)
+        if success and state
+          # switch out current state with new one
+          self.features = state
+        elsif not success
+          # If service is down, then slow our requests
+          # within this thread
+          sleep wait_between_fetch_failures
         end
+
+        # What ever happens never make more than N requests
+        # per second
+        sleep wait_between_fetch_success
+
+      rescue Exception => err
+        # catch errors, so that we do not affect the rest of the application
+        app.logger.error "load_state failed : #{err.message}\n#{err.backtrace.join("\n")}"
+        # hold off for a little while and try again
+        sleep wait_between_fetch_failures
       end
     end
 
-    def load_state
-      success, state = app.get("/features", { :verbose => true, :etag_wait => ETAG_WAIT }, true)
+    def load_state(use_cache=true)
+      success, state = app.get("/features", { :verbose => true, :etag_wait => ETAG_WAIT }, use_cache)
       if success and state
         state.each_pair do |feature_name, feature|
           feature["versions"].each_pair do |version_name, version|
@@ -109,8 +161,6 @@ module FluidFeatures
       version_name ||= ::FluidFeatures::DEFAULT_VERSION_NAME
       raise "version_name invalid : #{version_name}" unless version_name.is_a? String
 
-      #assert(isinstance(user_id, basestring))
-
       user_attributes ||= {}
       user_attributes["user"] = user_id.to_s
       if user_id.is_a? Integer
@@ -123,7 +173,10 @@ module FluidFeatures
       enabled = false
 
       feature = features[feature_name]
+      return false unless feature
       version = feature["versions"][version_name]
+      return false unless version
+
       modulus = user_id_hash % feature["num_parts"]
       enabled = version["parts"].include? modulus
 
@@ -150,5 +203,12 @@ module FluidFeatures
       enabled
     end
 
+    @private
+    def features_lock_synchronize
+      @features_lock.synchronize do
+        yield
+      end
+    end
+
   end
 end

data/lib/fluidfeatures/app/transaction.rb

@@ -11,7 +11,7 @@ module FluidFeatures
       @user = user
       @url  = url
 
-      # take a snap-shot of the features end at
+      # take a snap-shot of the features enabled state at
       # the beginning of the transaction
       @features = user.features
 

data/lib/fluidfeatures/client.rb

@@ -7,6 +7,7 @@ require "uuid"
 require "json"
 
 require "fluidfeatures/app"
+require 'fluidfeatures/exceptions'
 
 module FluidFeatures
   class Client
@@ -20,6 +21,9 @@ module FluidFeatures
 
     def initialize(base_uri, logger)
 
+      raise FFeaturesBadParam.new("base_uri is not String, is #{base_uri.class}") \
+        unless base_uri.is_a? String
+
       @uuid = UUID.new.generate
       @logger = logger
       @base_uri = base_uri

data/lib/fluidfeatures/config.rb

@@ -1,24 +1,57 @@
 
 require 'yaml'
-require 'erb'
+require 'fluidfeatures/exceptions'
 
 module FluidFeatures
   class Config
+
     attr_accessor :vars
-    def initialize(path, environment, replacements = {})
-      self.vars = YAML.load(ERB.new(File.read(path)).result)
-      self.vars = vars["common"].update(vars[environment])
-      self.vars = vars.update(replacements)
-      self.vars["cache"]["limit"] = self.class.parse_file_size(vars["cache"]["limit"]) if vars["cache"]
+
+    def initialize(source, environment=nil)
+      if source.is_a? String
+        init_from_file(source, environment)
+      elsif source.is_a? Hash
+        init_from_hash(source)
+      else
+        raise FFeaturesConfigInvalid.new(
+          "Invalid 'source' given. Expected file path String or Hash. Got #{source.class}"
+        )
+      end
+      if @vars["cache"] and @vars["cache"]["limit"]
+        @vars["cache"]["limit"] = self.class.parse_file_size(vars["cache"]["limit"])
+      end
     end
 
     def [](name)
       @vars[name.to_s]
     end
 
+    private
+
+    def init_from_file path, environment
+      unless File.exists? path
+        raise FFeaturesConfigFileNotExists.new("File not found : #{path}")
+      end
+      environments = YAML.load_file path
+      unless environments.is_a? Hash
+        raise FFeaturesConfigInvalid.new("Config is invalid : #{path}")
+      end
+      @vars = (environments["common"] || {}).clone
+      @vars.update environments[environment] if environments[environment]
+    end
+
+    def init_from_hash hash
+      @vars = hash.clone
+    end
+
     def self.parse_file_size(size)
-      return size if !size || size.is_a?(Numeric) || !/(\d+)\s*(kb|mb|gb)$/.match(size.downcase)
-      $1.to_i * 1024 ** (%w{kb mb gb}.index($2) + 1)
+      return size if size.is_a? Numeric
+      return size.to_i if size.is_a? String and size.match /^\d+$/
+      unless size.is_a? String and (/^(\d+)\s*(k|m|g)b$/i).match(size)
+        raise FFeaturesConfigInvalid.new("Invalid file size string in config : '#{size}'")
+      end
+      $1.to_i * 1024 ** ("kmg".index($2.downcase) + 1)
     end
+
   end
 end

data/lib/fluidfeatures/exceptions.rb

@@ -0,0 +1,16 @@
+
+class FFeaturesException < Exception
+end
+
+class FFeaturesConfigInvalid < FFeaturesException
+end
+
+class FFeaturesConfigFileNotExists < FFeaturesConfigInvalid
+end
+
+class FFeaturesBadParam < FFeaturesException
+end
+
+class FFeaturesAppStateLoadFailure < FFeaturesException
+end
+

data/lib/fluidfeatures/persistence/buckets.rb

@@ -3,14 +3,14 @@ module FluidFeatures
     class Buckets < Storage
       attr_accessor :limit
 
-      def self.create(config)
+      def self.create(config, logger=nil)
         return NullBuckets.new unless config && config["dir"] && config["enable"] && config["limit"] > 0
-        new(config)
+        new(config, logger)
       end
 
-      def initialize(config)
+      def initialize(config, logger=nil)
         self.limit = config["limit"]
-        super config
+        super
       end
 
       def fetch(n = 1)

data/lib/fluidfeatures/persistence/features.rb

@@ -2,18 +2,17 @@ module FluidFeatures
   module Persistence
     class Features < Storage
 
-      def self.create(config)
-        return NullFeatures.new unless config && config["dir"] && config["enable"]
-        new(config)
-      end
-
-      def initialize(config)
-        super config
+      def self.create(config, logger=nil)
+        if config && config["dir"] && config["enable"]
+          new(config, logger)
+        else
+          NullFeatures.new
+        end
       end
 
       def list
         store.transaction(true) do
-          return {} unless store && store["features"]
+          return nil unless store && store["features"]
           store["features"]
         end
       end
@@ -25,6 +24,7 @@ module FluidFeatures
         end
       end
 
+      # TODO: remove. we do not care about persisting these
       def list_unknown
         store.transaction(true) do
           return {} unless store && store["unknown_features"]
@@ -53,7 +53,7 @@ module FluidFeatures
     end
 
     class NullFeatures
-      def list; {} end
+      def list; nil end
       def list_unknown; {} end
       def replace(*args); false end
       def replace_unknown(*args); false end

data/lib/fluidfeatures/persistence/storage.rb

@@ -5,10 +5,10 @@ module FluidFeatures
     class Storage
       attr_accessor :dir, :file_name, :store, :logger
 
-      def initialize(config)
-        self.dir = config["dir"]
-        self.logger = config["logger"] || Logger.new(STDERR)
-        self.file_name = "#{self.class.to_s.split('::').last.downcase}.pstore"
+      def initialize(config, logger=nil)
+        @dir = config["dir"]
+        @logger = logger || Logger.new(STDERR)
+        @file_name = "#{self.class.to_s.split('::').last.downcase}.pstore"
         FileUtils.mkpath(dir) unless Dir.exists?(dir)
       end
 
@@ -21,11 +21,8 @@ module FluidFeatures
       end
 
       def file_size
-        begin
-          File.size(path)
-        rescue Exception => _
-          return 0
-        end
+        # TODO: rescue should return nil here
+        File.size(path) rescue 0
       end
     end
   end

data/lib/fluidfeatures/version.rb

@@ -1,3 +1,3 @@
 module FluidFeatures
-  VERSION = '0.5.0'
+  VERSION = '0.6.0'
 end

data/lib/fluidfeatures.rb

@@ -15,10 +15,10 @@ module FluidFeatures
     attr_accessor :config
   end
 
-  def self.app(config)
-    config["logger"] ||= ::Logger.new(STDERR)
+  def self.app(config, logger=nil)
+    logger ||= ::Logger.new(STDERR)
     self.config = config
-    client = ::FluidFeatures::Client.new(config["baseuri"], config["logger"])
-    ::FluidFeatures::App.new(client, config["appid"], config["secret"], config["logger"])
+    client = ::FluidFeatures::Client.new(config["base_uri"], logger)
+    ::FluidFeatures::App.new(client, config["app_id"], config["secret"], logger)
   end
-end
+end

data/spec/app/reporter_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe FluidFeatures::AppReporter do
 
-  it_should_behave_like "polling loop", :send_transactions do
+  it_should_behave_like "polling loop" do
     before(:each) { described_class.any_instance.stub(:transactions_queued?).and_return(true) }
   end
 
@@ -15,15 +15,15 @@ describe FluidFeatures::AppReporter do
     let(:transaction) { mock('transaction', url: 'http://example.com/source.html', duration: 999, user: user, unknown_features: [], features_hit: %w[feature], goals_hit: %w[goal]) }
 
     before(:each) do
-      described_class.any_instance.stub(:run_loop)
       FluidFeatures.stub(:config).and_return(config)
     end
 
     describe "#features_storage" do
       before(:each) do
         described_class.any_instance.stub(:configure)
-        FluidFeatures::Persistence::Features.should_receive(:create).with(config["cache"]).twice
-        .and_return(FluidFeatures::Persistence::NullFeatures.new)
+        FluidFeatures::Persistence::Features
+          .should_receive(:create).with(config["cache"])
+          .and_return(FluidFeatures::Persistence::NullFeatures.new)
       end
 
       it "should create features storage" do
@@ -184,6 +184,17 @@ describe FluidFeatures::AppReporter do
       end
     end
 
+    describe "#start_sending" do
+      it "#start_sending should call send_transactions" do
+        reporter.should_receive(:transactions_queued?).and_return(true)
+        # send_transactions needs to return success=true to prevent throttling
+        reporter.should_receive(:send_transactions).and_return(true)
+        reporter.start_sending
+        sleep(0.001) # wait for thread to start
+        reporter.stop_sending(wait=true)
+      end
+    end
+
     describe "#send_transactions" do
       let(:unknown_features) { { "feature" => { "a" => true } } }
 

data/spec/app/state_spec.rb

@@ -4,7 +4,7 @@ require "fluidfeatures/persistence/features"
 
 describe FluidFeatures::AppState do
 
-  it_should_behave_like "polling loop", :load_state
+  it_should_behave_like "polling loop"
 
   context do
     let(:state) { described_class.new(app) }
@@ -16,10 +16,14 @@ describe FluidFeatures::AppState do
     before(:each) do
       app.stub!(:is_a?).and_return(false)
       app.stub!(:is_a?).with(FluidFeatures::App).and_return(true)
-      described_class.any_instance.stub(:run_loop)
       FluidFeatures.stub(:config).and_return(config)
     end
 
+    after(:each) do
+      # ensure the loop is shutdown
+      state.stop_receiving(wait=true)
+    end
+
     describe "#features_storage" do
       before(:each) do
         described_class.any_instance.stub(:configure)
@@ -48,19 +52,26 @@ describe FluidFeatures::AppState do
         features = mock("features")
         features_storage.should_receive(:list).and_return(features)
         state.configure(app)
-        state.instance_variable_get(:@features).should == features
+        state.should_receive(:run_loop)
+        state.should_receive(:load_state).with(false).and_return([false,nil])
+        state.features.should == features
       end
     end
 
     describe "#features=" do
-      it "should replace features if there are changes" do
+      it "should replace features" do
         state.features_storage.should_receive(:replace).with({foo: "bar"})
         state.features = {foo: "bar"}
       end
+    end
 
-      it "should not replace features if not amended" do
-        state.features_storage.should_not_receive(:replace)
-        state.features = {}
+    describe "#start_receiving" do
+      it "#start_receiving should call load_state" do
+        # load_state needs to return success=true to prevent throttling
+        state.should_receive(:load_state).and_return([true,{}])
+        state.start_receiving
+        sleep(0.001) # wait for thread to start
+        state.stop_receiving(wait=true)
       end
     end
 

data/spec/config_spec.rb

@@ -1,18 +1,18 @@
 require "spec_helper"
+require 'fluidfeatures/exceptions'
 
 describe FluidFeatures::Config do
-  let(:path) { "#{File.dirname(__FILE__)}/fixtures/fluidfeatures.yml" }
+  let(:source) { "#{File.dirname(__FILE__)}/fixtures/fluidfeatures.yml" }
 
   let(:env) { "development" }
 
-  let(:replacements) { {} }
-
-  let(:config) { FluidFeatures::Config.new(path, env, replacements) }
+  let(:config) { FluidFeatures::Config.new(source, env) }
 
   context "parse file size" do
-    [nil, 1024, "foo"].each do |input|
-      it "should pass #{input.class.to_s} through" do
-        described_class.parse_file_size(input).should == input
+    [nil, "foo", Object.new, Object, [], {} ].each do |input|
+      it "should raise exception for non-matching #{input.class.to_s} #{input||'nil'}" do
+        expect { described_class.parse_file_size(input) }
+          .to raise_error(FFeaturesConfigInvalid)
       end
     end
 
@@ -21,6 +21,12 @@ describe FluidFeatures::Config do
         described_class.parse_file_size(i).should == o
       end
     end
+
+    { "123" => 123, "456" => 456 }.each do |i, o|
+      it "should read '#{i}' as #{o}" do
+        described_class.parse_file_size(i).should == o
+      end
+    end
   end
 
   %w{test development production}.each do |env_name|
@@ -29,25 +35,25 @@ describe FluidFeatures::Config do
 
       it "should load environment configuration from yml file and merge common section" do
         config.vars.should == {
-            "baseuri" => "baseuri",
+            "base_uri" => "base_uri",
             "cache" => { "enable" => false, "dir" => "cache_dir", "limit" => 2097152 },
-            "appid" => "#{env_name}_appid",
+            "app_id" => "#{env_name}_app_id",
             "secret" => "#{env_name}_secret"
         }
       end
+    end
+  end
 
-      context "and replacements" do
-        let(:replacements) { { "baseuri" => "env_baseuri", "appid" => "env_appid", "secret" => "env_secret" } }
-
-        it "should update variables with passed hash" do
-          config.vars.should == {
-              "baseuri" => "env_baseuri",
-              "cache" => { "enable" => false, "dir" => "cache_dir", "limit" => 2097152 },
-              "appid" => "env_appid",
-              "secret" => "env_secret"
-          }
-        end
-      end
+  context "with hash config" do
+    let(:source) { { "base_uri" => "env_base_uri", "app_id" => "env_app_id", "secret" => "env_secret" } }
+
+    it "should update variables with passed hash" do
+      config.vars.should == {
+        "base_uri" => "env_base_uri",
+        "app_id" => "env_app_id",
+        "secret" => "env_secret"
+      }
     end
   end
+
 end

data/spec/fixtures/fluidfeatures.yml

@@ -1,18 +1,18 @@
 common:
-  baseuri: baseuri
+  base_uri: base_uri
   cache:
     enable: false
     dir: cache_dir
     limit: 2mb
 
 development:
-  appid: development_appid
+  app_id: development_app_id
   secret: development_secret
 
 test:
-  appid: test_appid
+  app_id: test_app_id
   secret: test_secret
 
 production:
-  appid: production_appid
+  app_id: production_app_id
   secret: production_secret

data/spec/integration/fluidfeatures_spec.rb

@@ -4,12 +4,12 @@ describe "FluidFeatures" do
 
   describe "App initialization" do
     it "should raise 'host not set' without valid base uri" do
-      expect { FluidFeatures.app(config.remove("baseuri")) }.
-        to raise_error(StandardError, /host not set/)
+      expect { FluidFeatures.app(config.remove("base_uri")) }.
+        to raise_error(FFeaturesBadParam, /base_uri/)
     end
 
     it "should raise 'app_id invalid' without valid app id" do
-      expect { FluidFeatures.app(config.remove("appid")) }.
+      expect { FluidFeatures.app(config.remove("app_id")) }.
         to raise_error(StandardError, /app_id invalid/)
     end
 
@@ -19,7 +19,8 @@ describe "FluidFeatures" do
     end
 
     it "should set @config class variable to passed config" do
-      FluidFeatures::Client.stub!(:new); FluidFeatures::App.stub!(:new)
+      FluidFeatures::Client.stub!(:new)
+      FluidFeatures::App.stub!(:new)
       config = mock("config", "[]" => nil, "[]=" => nil)
       FluidFeatures.app(config)
       FluidFeatures.config.should == config
@@ -32,12 +33,28 @@ describe "FluidFeatures" do
 
     let(:feature) { app.features.pop[feature_name] }
 
+    before(:each) do
+      app.state.should_receive(:run_loop).once do
+        # only iterate once and not in a thread
+        app.state.run_loop_iteration(0,0)
+      end
+      app.reporter.should_receive(:run_loop).once do
+        # only iterate once and not in a thread
+        app.reporter.run_loop_iteration(0,0,0,0)
+      end
+    end
+
+    after(:each) do
+      # ensure the loop is shutdown
+      app.state.stop_receiving(wait=true)
+      app.reporter.stop_sending(wait=true)
+    end
+
     specify "#feature_enabled? should create feature" do
       VCR.use_cassette('feature') do
         transaction.feature_enabled?(feature_name, "a", true)
         transaction.feature_enabled?(feature_name, "b", true)
         commit transaction
-        sleep abit
         feature["name"].should == feature_name
         feature["versions"].size.should == 2
       end
@@ -51,5 +68,6 @@ describe "FluidFeatures" do
         sleep abit
       end
     end
+
   end
 end

data/spec/persistence/features_spec.rb

@@ -26,7 +26,7 @@ describe FluidFeatures::Persistence::Features do
   context "null instance" do
     let(:storage) { described_class.create(nil) }
 
-    specify { storage.list.should == {} }
+    specify { storage.list.should == nil }
 
     specify { storage.list_unknown.should == {} }
 
@@ -34,4 +34,4 @@ describe FluidFeatures::Persistence::Features do
 
     specify { storage.replace_unknown([["bucket0"], ["bucket1"]]).should == false }
   end
-end
+end

data/spec/spec_helper.rb

@@ -1,9 +1,4 @@
 
-unless ENV["FLUIDFEATURES_APPID"]
-  $stderr.puts "Expect ENV variabled FLUIDFEATURES_APPID FLUIDFEATURES_SECRET FLUIDFEATURES_BASEURI to run the tests"
-  exit!
-end
-
 require 'vcr'
 require 'fluidfeatures'
 

data/spec/support/api_helpers.rb

@@ -3,9 +3,9 @@ module FluidFeatures
     def config
       {
         "cache" => { "enable" => true, "dir" => "spec/tmp", "limit" => 1024 ** 2 },
-        "baseuri" => ENV["FLUIDFEATURES_BASEURI"],
-        "appid" => ENV["FLUIDFEATURES_APPID"],
-        "secret" => ENV["FLUIDFEATURES_SECRET"],
+        "base_uri" => "https://www.fluidfeatures.com/service",
+        "app_id" => "1vu33ki6emqe3",
+        "secret" => "secret",
         "logger" => Logger.new("/dev/null")
       }
     end

data/spec/support/polling_loop_shared_examples.rb

@@ -1,4 +1,4 @@
-shared_examples "polling loop" do |payload_method|
+shared_examples "polling loop" do
   let(:app) { mock "FluidFeatures::App" }
 
   before(:each) do
@@ -22,18 +22,12 @@ shared_examples "polling loop" do |payload_method|
       described_class.new(app)
     end
 
-    it "should call #run_loop" do
-      described_class.any_instance.should_receive(:run_loop)
+    it "should not call #run_loop" do
+      described_class.any_instance.should_not_receive(:run_loop)
       described_class.new(app)
     end
   end
 
-  it "#run_loop should call payload method" do
-    described_class.any_instance.should_receive(payload_method)
-    described_class.new(app)
-    sleep 0.15
-  end
-
   it "should initialize @app" do
     described_class.new(app).app.should == app
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fluidfeatures
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-08 00:00:00.000000000 Z
+date: 2013-01-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: persistent_http
@@ -165,6 +165,7 @@ files:
 - lib/fluidfeatures/client.rb
 - lib/fluidfeatures/config.rb
 - lib/fluidfeatures/const.rb
+- lib/fluidfeatures/exceptions.rb
 - lib/fluidfeatures/persistence/buckets.rb
 - lib/fluidfeatures/persistence/features.rb
 - lib/fluidfeatures/persistence/storage.rb