glowworm 0.3.0

data/Rakefile

@@ -0,0 +1,29 @@
+require "bundler"
+require "rake/testtask"
+
+require File.join(File.dirname(__FILE__), "lib", "glowworm", "version")
+
+desc "Run all tests"
+task "test" => [ "test:units", "test:integration" ]
+
+Rake::TestTask.new("test:units") do |t|
+  t.libs << "test"
+  t.test_files = Dir.glob("test/units/*test.rb")
+  t.verbose = true
+end
+
+Rake::TestTask.new("test:integration") do |t|
+  t.libs << "test"
+  t.test_files = Dir.glob("test/integration/*test.rb")
+  t.verbose = true
+end
+
+desc 'Builds the gem'
+task :build do
+  sh "gem build glowworm.gemspec"
+end
+
+desc 'Builds and installs the gem'
+task :install => :build do
+  sh "gem install glowworm-#{Glowworm::VERSION}"
+end

data/bin/basic_server_tester

@@ -0,0 +1,311 @@
+#!/usr/bin/env ruby
+
+require "trollop"
+OPTS = Trollop.options do
+  opt :server,          "Glowworm server URL",         :default => "localhost:4999"
+  opt :raise_on_assert, "Raise exception on failure",  :default => false
+  opt :nbg,           "Run Glowworm in no_bg mode",  :default => false
+end
+
+require "glowworm"
+Glowworm.server = OPTS[:server]
+STATS = Hash.new(0)
+FAKE_LOGGER = Object.new
+STATS[:logger_error] = 0
+STATS[:logger_warning] = 0
+STATS[:logger_critical] = 0
+STATS[:logger_fatal] = 0
+STATS[:assert_count] = 0
+STATS[:success] = 0
+STATS[:failure] = 0
+
+def FAKE_LOGGER.error(*args)
+  STDERR.puts("ERROR ", *args)
+  STATS[:logger_error] += 1
+end
+def FAKE_LOGGER.warn(*args)
+  STDERR.puts("WARN ", *args)
+  STATS[:logger_warning] += 1
+end
+def FAKE_LOGGER.critical(*args)
+  STDERR.puts("CRITICAL ", *args)
+  STATS[:logger_critical] += 1
+end
+def FAKE_LOGGER.fatal(*args)
+  STDERR.puts("FATAL ", *args)
+  STATS[:logger_fatal] += 1
+end
+def FAKE_LOGGER.debug(*args);
+  STDERR.puts("DEBUG ", *args)
+end
+def FAKE_LOGGER.info(*args);
+  STDERR.puts("INFO ", *args)
+end
+
+Glowworm.termite_logger = FAKE_LOGGER
+Glowworm.termite_logger.debug("using ecology data: ", Ecology.data.to_s)
+
+if OPTS[:nbg]
+  if Glowworm::VERSION < "0.1.6"
+    exit 0
+  end
+  Glowworm.no_bg
+else
+  # Get things started
+  Glowworm.prefetch(:all, :all)
+end
+
+require "minitest/autorun"
+require "minitest/unit"
+require "minitap"
+
+if ENV["TEST_GLOWWORM_VERSION"] && ENV["TEST_GLOWWORM_VERSION"] != "latest" && Glowworm::VERSION != ENV["TEST_GLOWWORM_VERSION"]
+  fail "Should be testing under #{ENV["TEST_GLOWWORM_VERSION"]}"
+end
+
+$stderr.puts "Glowworm version: #{Glowworm::VERSION}"
+
+class Tester < MiniTest::Unit::TestCase
+  def test_large_timeout
+    if Glowworm::VERSION < "0.1.6"
+      assert_equal(10.0, Glowworm.timeout, "timeout must be 10.0")
+    elsif Glowworm.threadless
+      assert_equal(0.0, Glowworm.timeout, "timeout must be 0 with no bg")
+    else
+      assert_equal(10.0, Glowworm.timeout, "timeout must be 10.0")
+    end
+  end
+
+  def test_123_foo
+    assert Glowworm.feature_flag(123, 'foo'),
+           "Feature_flag(123, 'foo') should always return true on a test dataset."
+  end
+
+  def test_low_ttl_timeout
+    (1..100).each do
+      assert Glowworm.feature_flag(123, 'foo', :ttl => 0, :timeout => 1),
+        "Feature_flag(123, 'foo') should always return true on a test dataset."
+      sleep 0.1
+    end
+  end
+
+  ONE_HORSE_TOWN = 1
+  TWO_HORSE_TOWN = 2
+  NO_HORSE_TOWN = 3
+
+  def feature_flag_test_with_override(override, fully_active)
+    if Glowworm::VERSION <= "0.0.15" && nil != override
+      skip "glowworm 0.0.15 and less are known not to behave as expected with a override"
+    end
+
+    if Glowworm::VERSION <= "0.0.22" && fully_active
+      skip "glowworm 0.0.22 and less do not implement fully_active"
+    end
+
+    [[], [ONE_HORSE_TOWN], [ONE_HORSE_TOWN, TWO_HORSE_TOWN]].each do |acct_sets|
+      num_accts = acct_sets.size
+      offset = override.nil? ? 0 : (override == true ? 1 : 2)
+      offset += 3 if fully_active
+      id = 1000 + offset * 100 + num_accts
+      account = "account_for_acct_sets_#{num_accts}_#{override.inspect}"
+      feature = "#{fully_active ? "fully_active_" : ""}feature_for_acct_sets_#{num_accts}_#{override.inspect}"
+
+      actual_values = {}
+      actual_values[:no_default] = Glowworm.feature_flag(account, feature)
+      [ true, false, 5, 0, nil, :default ].each do |default_value|
+        actual_values[default_value] = Glowworm.feature_flag(account, feature, :default => default_value)
+      end
+
+      if override != nil
+        # If there is an override, it should always be returned
+        actual_values.keys.each do |value|
+          assert_equal override, actual_values[value],
+            "With override of #{override.inspect}, feature_flag(#{account.inspect}, #{feature.inspect}) " +
+              "default #{value.inspect} must return #{override.inspect} not #{actual_values[value].inspect}"
+        end
+      else
+        if num_accts == 0
+          # If feature isn't active for any account_sets and there's no override,
+          # the default should be returned.
+          (actual_values.keys - [:no_default]).each do |value|
+            assert_equal value, actual_values[value],
+              "With no override and no account_sets active, feature_flag must " +
+              "return the default value of #{value.inspect}!"
+          end
+
+          assert_equal fully_active, actual_values[:no_default],
+            "With no override, no account_sets active #{fully_active ? "a fully active feature " : ""}and no default, " +
+            "feature_flag must return the (default) default value of #{fully_active}!"
+        elsif num_accts == 1
+          # If feature is switched for an account_set and there's no override,
+          # we should return the switched value.
+          actual_values.keys.each do |value|
+            assert_equal true, actual_values[value],
+              "With no override and one acct set active, feature_flag must " +
+              "return true!"
+          end
+        elsif num_accts == 2
+          # If feature is switched for two account_sets and there's no override,
+          # we should return the switched value.
+          actual_values.keys.each do |value|
+            assert_equal true, actual_values[value],
+              "With no override and two acct sets active, feature_flag must " +
+              "return true!"
+          end
+        else
+          raise "How many account sets are you testing, anyway?"
+        end
+      end
+    end
+  end
+
+  def self.add_feature_flag_test_with_override(override, fully_active)
+    instance_eval do
+      define_method "test_#{fully_active ? "fully_active_" : ""}feature_flag_with_override_#{override.inspect}" do
+        feature_flag_test_with_override(override, fully_active)
+      end
+    end
+  end
+
+  # test feature flags with various override settings
+  [nil, true, false].product([false, true]).each do |override, fully_active|
+    add_feature_flag_test_with_override(override, fully_active)
+  end
+
+  # Get_value testing loop
+
+  LOW_ID_SET = 4
+  BIG_VALUE_SET = 5
+  LITTLE_VALUE_SET = 6
+
+  VALUE_FOR_ACCT_SET = {
+    ONE_HORSE_TOWN => 1,
+    TWO_HORSE_TOWN => 2,
+    BIG_VALUE_SET => 100,
+    LITTLE_VALUE_SET => 7,
+    LOW_ID_SET => 21,
+  }
+
+  def feature_value_test_with_override(override)
+    if Glowworm::VERSION <= "0.0.15" && nil != override
+      skip "glowworm 0.0.15 and less are known not to behave as expected with a override"
+    elsif Glowworm::VERSION < "0.1.4" && nil == override
+      skip "glowworm 0.1.2 and less are known not to behave as expected for a feature value in multiple sets"
+    end
+
+    counter = 0
+    [[],
+     [LITTLE_VALUE_SET],
+     [BIG_VALUE_SET, LITTLE_VALUE_SET],
+     [BIG_VALUE_SET, LITTLE_VALUE_SET, LOW_ID_SET]].each do |acct_sets|
+      acct_key = acct_sets.map(&:to_s).join("/")
+      id = 2000 + (override.nil? ? 0 : override + 1) * 100 + counter
+      counter += 1
+      account = "account_for_value_acct_sets_#{acct_key}_#{override.inspect}"
+      feature = "feature_for_value_acct_sets_#{acct_key}_#{override.inspect}"
+
+      actual_values = {}
+      actual_values[:no_default] = Glowworm.feature_flag(account, feature, :get_value => true)
+      assert_equal actual_values[:no_default], Glowworm.feature_value(account, feature),
+        "Glowworm must return the same value for .feature_value and .feature_flag(:get_value => true)!"
+      [ true, false, 5, 0, :default ].each do |default_value|
+        actual_values[default_value] = Glowworm.feature_flag(account, feature,
+                                                             :default => default_value, :get_value => true)
+        assert_equal actual_values[default_value], Glowworm.feature_value(account, feature,
+                                                                          :default => default_value),
+          "Glowworm must return the same value for .feature_value and .feature_flag(:get_value => true)!"
+      end
+
+      if override != nil
+        # If there is an override, it should always be returned
+        actual_values.keys.each do |value|
+          assert_equal override, actual_values[value],
+            "With override of #{override.inspect}, feature_value(#{account.inspect}, #{feature.inspect}) " +
+              "default #{value.inspect} must return #{override.inspect} not #{actual_values[value].inspect}"
+        end
+      elsif acct_sets == []
+        # If feature isn't active for any account_sets and there's no override,
+        # the default should be returned.
+        (actual_values.keys - [:no_default]).each do |value|
+          assert_equal value, actual_values[value],
+            "With no override and no account_sets active, feature_value must " +
+            "return the default value of #{value.inspect}!"
+        end
+
+        assert_equal false, actual_values[:no_default],
+          "With no override, no account_sets active and no default, feature_value must " +
+          "return the (default) default value of false!"
+      elsif acct_sets.include?(LOW_ID_SET)
+        # If the feature is active for the set with the lowest
+        # account_set id and there's no override, it must return the
+        # value for that account_set id.
+        actual_values.keys.each do |value|
+         assert_equal VALUE_FOR_ACCT_SET[LOW_ID_SET], actual_values[value],
+           "With no override and the lowest-id account_set active, feature_value must " +
+           "return that account_set's value of #{VALUE_FOR_ACCT_SET[LOW_ID_SET]}!"
+        end
+      elsif acct_sets.include?(BIG_VALUE_SET)
+        # If the feature is active for the set with a lower account_set
+        # id and there's no override, it must return the value for that
+        # account_set id.
+        actual_values.keys.each do |value|
+         assert_equal VALUE_FOR_ACCT_SET[BIG_VALUE_SET], actual_values[value],
+           "With no override and the lowest-id account_set active, feature_value must " +
+           "return that account_set's value of #{VALUE_FOR_ACCT_SET[BIG_VALUE_SET]}!"
+        end
+      elsif acct_sets.include?(LITTLE_VALUE_SET)
+        # If the feature is active for the set with a lower account_set
+        # id and there's no override, it must return the value for that
+        # account_set id.
+        actual_values.keys.each do |value|
+          STDERR.puts "With no override and the lowest-id account_set active, feature_value must " +
+            "return that account_set's value of #{VALUE_FOR_ACCT_SET[LITTLE_VALUE_SET]}.  " +
+            "Actual value returned is #{actual_values[value]}"
+        end
+      else
+        raise "You're testing some set of accounts I don't recognize!"
+      end
+    end
+  end
+
+  def self.add_feature_value_test_with_override(override)
+    instance_eval do
+      define_method "test_feature_value_with_override_#{override.inspect}" do
+        feature_value_test_with_override(override)
+      end
+    end
+  end
+
+  # Basic testing loop...
+  [nil, 0, 1, 2, 5].each do |override|
+    add_feature_value_test_with_override(override)
+  end
+end
+
+module MiniTest::Assertions
+  alias :old_assert :assert
+  def assert(test, msg = nil)
+    STATS[:assert_count] += 1
+    begin
+      old_assert(test, msg)
+      STATS[:success] += 1
+    rescue MiniTest::Assertion
+      STATS[:failure] += 1
+      raise
+    end
+  end
+end
+
+MiniTest::Unit.runner = MiniTest::TapY.new
+
+# Output STATS to STDERR for easy debugging
+MiniTest::Unit.after_tests do
+  STDERR.puts "Success: #{STATS[:success]}"
+  STDERR.puts "Failure: #{STATS[:failure]}"
+  STDERR.puts "Assert Count: #{STATS[:assert_count]}"
+  STDERR.puts "Logger warning: #{STATS[:logger_warning]}"
+  STDERR.puts "Logger error: #{STATS[:logger_error]}"
+  STDERR.puts "Logger critical: #{STATS[:logger_critical]}"
+  STDERR.puts "Logger fatal: #{STATS[:logger_fatal]}"
+end
+

data/bin/em_server/config.ru

@@ -0,0 +1,2 @@
+require "./bin/em_server/em_server"
+run EMServer

data/bin/em_server/em_server.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+require "thin"
+require "sinatra/base"
+require "glowworm/em"
+require "sinatra/synchrony"
+
+class EMServer < Sinatra::Base
+  register Sinatra::Synchrony
+
+  get "/update" do
+    Glowworm.update_cache_in_foreground
+    "updated!"
+  end
+
+  get "/" do
+    val = Glowworm.feature_value(123, "foo")
+    val.to_s
+  end
+end

data/bin/em_server_tester

@@ -0,0 +1,68 @@
+#!/usr/bin/env ruby
+
+require "net/http"
+require "minitest/autorun"
+require "minitest/unit"
+require "minitap"
+require "trollop"
+require "httparty"
+
+OPTS = Trollop.options do
+  opt :server,  "EM server URL", :type => String
+end
+
+STATS = Hash.new(0)
+STATS[:logger_error] = 0
+STATS[:logger_warning] = 0
+STATS[:logger_critical] = 0
+STATS[:logger_fatal] = 0
+STATS[:assert_count] = 0
+STATS[:success] = 0
+STATS[:failure] = 0
+
+class Tester < MiniTest::Unit::TestCase
+  def test_em_get
+    begin
+      url = OPTS[:server]
+      assert_equal "1", HTTParty.get(url).to_s, "Request should return 1"
+    rescue
+      assert false, "request to #{url} failed"
+    end
+  end
+
+  def test_em_update
+    begin
+      url = OPTS[:server] + "/update"
+      assert_equal "updated!", HTTParty.get(url).to_s, "Update should succeed"
+    rescue
+      assert false, "request to #{url} failed"
+    end
+  end
+end
+
+module MiniTest::Assertions
+  alias :old_assert :assert
+  def assert(test, msg = nil)
+    STATS[:assert_count] += 1
+    begin
+      old_assert(test, msg)
+      STATS[:success] += 1
+    rescue MiniTest::Assertion
+      STATS[:failure] += 1
+      raise
+    end
+  end
+end
+
+MiniTest::Unit.runner = MiniTest::TapY.new
+
+# Output STATS to STDERR for easy debugging
+MiniTest::Unit.after_tests do
+  STDERR.puts "Success: #{STATS[:success]}"
+  STDERR.puts "Failure: #{STATS[:failure]}"
+  STDERR.puts "Assert Count: #{STATS[:assert_count]}"
+  STDERR.puts "Logger warning: #{STATS[:logger_warning]}"
+  STDERR.puts "Logger error: #{STATS[:logger_error]}"
+  STDERR.puts "Logger critical: #{STATS[:logger_critical]}"
+  STDERR.puts "Logger fatal: #{STATS[:logger_fatal]}"
+end

data/bin/glowworm

@@ -0,0 +1,90 @@
+#!/usr/bin/env ruby
+
+require "trollop"
+require "pp"
+require "glowworm"
+
+opts = Trollop::options do
+  opt :feature, "What feature name to query", :type => String, :default => "video_rec"
+  opt :account, "What account to query", :type => String, :default => "35"
+  opt :debug, "Whether to debug", :type => :boolean, :default => false
+  opt :dump_cache, "Whether to dump the Glowworm cache", :type => :boolean, :default => false
+  opt :load_test, "How many times to repeat the query", :type => :int, :default => 1
+  banner <<BANNER
+Glowworm is a program to query the feature flags of accounts and providers.
+
+  Usage:  #{$0} [options] [server name]
+
+With a specific feature and account, Glowworm will print true or false, or
+raise an exception if data can't be gotten.
+
+You can specify "all" for the --feature or --account parameters to query all.
+Doing both will dump a *lot* of data, so redirect to a file.
+
+Options:
+BANNER
+end
+
+# Fake logger that ignores all calls
+fake_logger = Object.new
+def fake_logger.method_missing(*args); end
+sensitive_logger = ::Termite::Logger.new(STDOUT)
+sensitive_logger.level = ::Logger::INFO
+
+Glowworm.server = ARGV.pop || "localhost:4999"
+Glowworm.timeout = 5.0  # 5-second timeout by default
+Glowworm.termite_logger = opts[:debug] ? sensitive_logger : fake_logger
+Ecology.read  # No ecology, must set options manually.
+
+if opts[:debug]
+  puts <<END
+Glowworm v#{Glowworm::VERSION}
+Querying server #{Glowworm.server}
+Feature #{opts[:feature]}, account #{opts[:account]}
+END
+end
+
+opts[:account] = :all if opts[:account] == "all"
+opts[:feature] = :all if opts[:feature] == "all"
+
+if opts[:account] == :all || opts[:feature] == :all
+  puts "Prefetching: #{opts[:account]}, #{opts[:feature]}" if opts[:debug]
+  Glowworm.prefetch opts[:account], opts[:feature]
+
+  # Prefetch is instant, so we need to wait until the prefetch returns
+  Glowworm.feature_flag("fake_acct", "fake_flag")
+
+  accounts = opts[:account] == :all ? Glowworm.all_cached_accounts : [ opts[:account] ]
+  features = opts[:feature] == :all ? Glowworm.all_cached_features : [ opts[:feature] ]
+
+  STDERR.puts "Accounts: #{accounts.inspect}" if opts[:debug]
+  STDERR.puts "Features: #{features.inspect}" if opts[:debug]
+
+  cached_features = {}
+  accounts.each do |account|
+    cached_features[account] = {}
+    features.each do |feature|
+      flag = Glowworm.feature_flag(account, feature, :ttl => 1_000_000, :timeout => 0.0)
+      cached_features[account][feature] = flag
+    end
+  end
+
+  pp cached_features
+else
+  opts[:load_test].times do
+    # 0 TTL means "always actually fetch, never treat as fresh"
+    puts "Querying #{Glowworm.server}, feature #{opts[:feature]}, account #{opts[:account]}:"
+    puts Glowworm.feature_flag(opts[:account], opts[:feature], :ttl => 0.0).inspect
+  end
+end
+
+if opts[:dump_cache]
+  puts "*************** Dumping Glowworm Cache: ****************"
+  puts "\nGlowworm feature cache:"
+  pp Glowworm.feature_cache
+  puts "\nGlowworm account_set cache:"
+  pp Glowworm.account_set_cache
+  puts "\nGlowworm override cache:"
+  pp Glowworm.override_cache
+  puts "********************************************************"
+end